OC底层原理探索文档汇总

自动释放池是OC中的一种自动垃圾回收机制。属于内存管理的一种方案。

主要内容：

自动释放池的认识

自动释放池的本质

自动释放池的压栈和出栈过程分析

1、自动释放池的认识

1.1 介绍

自动释放池是OC的一种自动垃圾回收机制，用来管理对象的释放。它可以将加入到autoreleasePool中的对象的release时机延迟。

正常情况下，当一个对象停止指向某一个变量时，该对象会立即进行release。但是如果该对象加入到了自动释放池中，这个对象并不会立即release。而是会等到runloop休眠或者超出autoreleasePool作用域{}之后才会被释放。

自动释放池的过程.png

说明：

从程序启动到加载完成，主线程对应的runloop会处于休眠状态，等待用户交互来唤醒runloop。
用户的每一次交互都会唤醒一次runloop，用于处理用户的所有点击、触摸事件等。
runloop在监听到交互事件后，就会创建自动释放池，并将所有延迟释放的对象添加到自动释放池中。
在一次完整的runloop结束之前，会向自动释放池中所有对象发送release消息，然后销毁自动释放池

1.2 查看autoreleasePool的本质

通过Clang进行分析

定义代码：

int main(int argc, const char * argv[]) {
    @autoreleasepool {
    }
}

查看编译后的结果

struct __AtAutoreleasePool {
  __AtAutoreleasePool() {atautoreleasepoolobj = objc_autoreleasePoolPush();}
  ~__AtAutoreleasePool() {objc_autoreleasePoolPop(atautoreleasepoolobj);}
  void * atautoreleasepoolobj;
};

int main(int argc, char * argv[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 
    }
}

说明：

可以看到在底层其实是使用一个__AtAutoreleasePool结构体来实现的
自动释放池的作用范围就是__AtAutoreleasePool()构造成功后到~__AtAutoreleasePool()析构结束，中间的代码就是属于自动释放池{}中执行的代码
该结构体构造函数和析构函数分别使用objc_autoreleasePoolPush和objc_autoreleasePoolPop来实现的。

总结：

自动释放池本质是一个结构体，是一个类（后续会说明）
调用构造函数就是作用域的开始
调用析构函数就是作用域的结束
其中{} 是作用域，优点是结构清晰，可读性强，可以及时创建销毁

自定义一个结构体来验证作用域

//包括构造函数和析构函数
struct WYTest{
    WYTest(){
        printf("作用域开始 - %s\n", __func__);
    }
    ~WYTest(){
        printf("作用域结束 - %s\n", __func__);
    }
};

int main(int argc, char * argv[]) {
    {
        printf("WY:嘿嘿-作用域前 - %s\n", __func__);
        WYTest test;
        printf("WY：哈哈-作用域中 - %s\n", __func__);
    }
    printf("WY：嘻嘻- 作用域后 - %s\n", __func__);
}

运行结果：

WY:嘿嘿-作用域前 - main
作用域开始 - WYTest
WY：哈哈-作用域中 - main
作用域结束 - ~WYTest
WY：嘻嘻- 作用域后 - main

说明：

可以看到作用域的范围就是构造函数和析构函数中间的范围
在{}中执行WYTest test，那么这个{}范围就是从这条语句之后到该代码块结束

2、底层分析

2.1 首先看下objc源码中是如何描述自动释放池的

Autorelease pool implementation

- A thread's autorelease pool is a stack of pointers. 
线程的自动释放池是存储指针的栈

- Each pointer is either an object to release, or POOL_BOUNDARY which is an autorelease pool boundary.
每个指针都是要释放的对象，或者是POOL_BOUNDARY，它是自动释放池的边界。

- A pool token is a pointer to the POOL_BOUNDARY for that pool. When the pool is popped, every object hotter than the sentinel is released.
池令牌是指向该池的POOL_BOUNDARY的指针。弹出池后，将释放比哨点更热的每个对象。

- The stack is divided into a doubly-linked list of pages. Pages are added and deleted as necessary. 
堆栈分为两个双向链接的页面列表。根据需要添加和删除页面。

- Thread-local storage points to the hot page, where newly autoreleased objects are stored. 
线程本地存储指向热页面，该页面存储新自动释放的对象。

说明：

自动释放池是依赖于线程的。线程拥有自动释放池（基于RunLoop管理）。
自动释放池本质是一个存储有指针的栈，指针包含对象指针和边界指针。
自动释放池会有一个token令牌指向池边界，当池子执行了pop之后，所有非边界对象都会被release掉。此时这些对象都要比边界对象更热。边界对象并不会被release，它作为边界嘛。
栈在底层是双向链表结构的，这样可以快速的添加和删除对象。
线程本地存储指向热的页，该页面存储新自动释放的对象。
以双向链表的栈结构构成页

2.2 自动释放池的认识

2.2.1 查看源码

//***********push方法***********
void *
objc_autoreleasePoolPush(void)
{
    return AutoreleasePoolPage::push();
}

//***********pop方法***********
void
objc_autoreleasePoolPop(void *ctxt)
{
    AutoreleasePoolPage::pop(ctxt);
}

说明：

自动释放池的底层结构是AutoreleasePoolPage，是一个页结构
通过调用push和pop来管理池子，push创建池子，pop就是析构池子，当pop后就会将池子中所有的对象release掉

2.2.2 AutoreleasePoolPage

//************宏定义************
#define PAGE_MIN_SIZE           PAGE_SIZE
#define PAGE_SIZE               I386_PGBYTES
#define I386_PGBYTES            4096            /* bytes per 80386 page */

//************类定义************
class AutoreleasePoolPage : private AutoreleasePoolPageData
{
    friend struct thread_data_t;

public:
    //页的大小
    static size_t const SIZE =
#if PROTECT_AUTORELEASEPOOL
        PAGE_MAX_SIZE;  // must be multiple of vm page size
#else
        PAGE_MIN_SIZE;  // size and alignment, power of 2
#endif

private:
    
    ...
    
    //构造函数
    AutoreleasePoolPage(AutoreleasePoolPage *newParent) :
        AutoreleasePoolPageData(begin(),//开始存储的位置
                                objc_thread_self(),//传的是当前线程，当前线程时通过tls获取的
                                newParent,
                                newParent ? 1+newParent->depth : 0,//如果是第一页深度为0，往后是前一个的深度+1
                                newParent ? newParent->hiwat : 0)
    {...}
    
    //析构函数
    ~AutoreleasePoolPage() {...}
    
    ...
    
    //页的开始位置
    id * begin() {...}
    
    //页的结束位置
    id * end() {...}
   
    //页是否为空
    bool empty() {...}
    
    //页是否满了
    bool full() {...}
   
    //页的存储是否少于一半
    bool lessThanHalfFull() {...}
     
     //添加释放对象
    id *add(id obj){...}
    
    //释放所有对象
    void releaseAll() {...}
    
    //释放到stop位置之前的所有对象
    void releaseUntil(id *stop) {...}
    
    //杀掉
    void kill() {...}
    
    //释放本地线程存储空间
    static void tls_dealloc(void *p) {...}
    
    //获取AutoreleasePoolPage
    static AutoreleasePoolPage *pageForPointer(const void *p) {...}
    static AutoreleasePoolPage *pageForPointer(uintptr_t p)  {...}
    
    //是否有空池占位符
    static inline bool haveEmptyPoolPlaceholder() {...}
    
    //设置空池占位符
    static inline id* setEmptyPoolPlaceholder(){...}
    
    //获取当前操作页
    static inline AutoreleasePoolPage *hotPage(){...}
    
    //设置当前操作页
    static inline void setHotPage(AutoreleasePoolPage *page) {...}
    
    //获取coldPage
    static inline AutoreleasePoolPage *coldPage() {...}
    
    //快速释放
    static inline id *autoreleaseFast(id obj){...}
   
   //添加自动释放对象，当页满的时候调用这个方法
    static __attribute__((noinline))
    id *autoreleaseFullPage(id obj, AutoreleasePoolPage *page) {...}
    
    //添加自动释放对象，当没页的时候使用这个方法
    static __attribute__((noinline))
    id *autoreleaseNoPage(id obj){...}
   
   //创建新页
    static __attribute__((noinline))
    id *autoreleaseNewPage(id obj) {...}
    
public:
    //自动释放
    static inline id autorelease(id obj){...}
   
    //入栈
    static inline void *push() {...}
    
    //兼容老的 SDK 出栈方法
    __attribute__((noinline, cold))
    static void badPop(void *token){...}
    
    //出栈页面
    template<bool allowDebug>
    static void
    popPage(void *token, AutoreleasePoolPage *page, id *stop){...}
    __attribute__((noinline, cold))
    static void
    popPageDebug(void *token, AutoreleasePoolPage *page, id *stop){...}
    
    //出栈
    static inline void
    pop(void *token){...}
    
    static void init(){...}
    
    //打印
    __attribute__((noinline, cold))
    void print(){...}
    
    //打印所有
    __attribute__((noinline, cold))
    static void printAll(){...}
    
    //打印Hiwat
    __attribute__((noinline, cold))
    static void printHiwat(){...}

说明：

AutoreleasePoolPage继承自AutoreleasePoolPageData
AutoreleasePoolPage的大小是4096个字节
通过AutoreleasePoolPage()进行构造，其内部可以看到是通过AutoreleasePoolPageData()来构造的
和~AutoreleasePoolPage()进行析构
涉及API也可以简单看看，后续对池子的操作会用到
有关于页的操作，比如full()、hotPage()、autoreleaseNewPage(id obj)、push()、pop(void *token)
有关于对象的操作，比如add()、releaseAll()、autorelease(id obj)

2.2.3 AutoreleasePoolPageData

它是AutoreleasePoolPage的父类

class AutoreleasePoolPage;
struct AutoreleasePoolPageData
{
    //用来校验AutoreleasePoolPage的结构是否完整
    magic_t const magic;//16个字节
    //指向最新添加的autoreleased对象的下一个位置，初始化时指向begin()
    __unsafe_unretained id *next;//8字节
    //指向当前线程
    pthread_t const thread;//8字节
    //指向父节点，第一个结点的parent值为nil
    AutoreleasePoolPage * const parent;//8字节
    //指向子节点，最后一个结点的child值为nil
    AutoreleasePoolPage *child;//8字节
    //表示深度，从0开始，往后递增1
    uint32_t const depth;//4字节
    //表示high water mark 最大入栈数量标记
    uint32_t hiwat;//4字节

    //初始化
    AutoreleasePoolPageData(__unsafe_unretained id* _next, pthread_t _thread, AutoreleasePoolPage* _parent, uint32_t _depth, uint32_t _hiwat)
        : magic(), next(_next), thread(_thread),
          parent(_parent), child(nil),
          depth(_depth), hiwat(_hiwat)
    {
    }
};

说明：

自动释放池有自己所在的线程
自动释放池是由多张页组成，这些页是以双向链表结构的形式存在，可以指向前一页和后一页
depth可以当前页所在的位置，如果该页是第一页深度为0，如果是第二页，深度为1
并且AutoreleasePoolPageData结构体的内存大小为56字节
- 属性magic 的类型是magic_t结构体，所占内存大小为m[4];所占内存（即4*4=16字节）
- 属性next（指针）、thread（对象）、parent（对象）、child（对象）均占8字节（即4*8=32字节）
- 属性depth、hiwat类型为uint32_t，实际类型是unsigned int类型，均占4字节（即2*4=8字节）

2.3 自动释放池的创建，也就是AutoreleasePoolPage的构造

2.3.1 push()

代码：

static inline void *push() 
    {
        id *dest;
        if (slowpath(DebugPoolAllocation)) {
            // Each autorelease pool starts on a new pool page.
            //创建一个新的池子
            dest = autoreleaseNewPage(POOL_BOUNDARY);
        } else {
            //压栈一个边界指针
            dest = autoreleaseFast(POOL_BOUNDARY);
        }
        ASSERT(dest == EMPTY_POOL_PLACEHOLDER || *dest == POOL_BOUNDARY);
        return dest;
    }

说明：

调用push构造池子，我们可以看到有两种情况来构造
第一种是slowpath，而且是debug状态下的，所以只看第二种autoreleaseFast方式，在创建池子的同时压入一个边界对象

2.3.2 autoreleaseFast()

源码：

//添加一个对象
static inline id *autoreleaseFast(id obj)
{
    //获取当前页
    AutoreleasePoolPage *page = hotPage();
    //如果当前页存在，并且没有填满，就可以添加一个需要release的对象或者边界对象
    if (page && !page->full()) {
        return page->add(obj);
    } else if (page) {//如果已满，就获取child页或者新建页
        return autoreleaseFullPage(obj, page);
    } else {//如果当前页不存在就说明当前池子就根本还没有页，就新建第一页
        return autoreleaseNoPage(obj);
    }
}

说明：

可以看到获取当前页有三种情况
如果当前页存在，而且可以存储没有填满，就直接add添加
如果当前页存在，但是已经满了，就需要通过autoreleaseFullPage()存储到其他页，如果所有页都满了就需要新建页
如果根本没有当前页，说明还不存在池子，就新建第一页autoreleaseNoPage()

2.3.3 add()

源码：

//开始位置
id * begin() {
    //偏移页结构体的结构体本身大小的位置，说明就是入栈对象的初始位置
    return (id *) ((uint8_t *)this+sizeof(*this));
}

//最后对象位置
id * end() {
    //偏移页结构体的最大位置，也就是页的最后位置
    return (id *) ((uint8_t *)this+SIZE);
}

//判断是否为空
bool empty() {
    //如果当前对象位置是初始位置，说明是空的
    return next == begin();
}

//判断是否已满
bool full() {
    //next就是当前对象所指向的位置
    //end()是每页最后的位置
    return next == end();
}

//将对象obj赋给当前对象位置next，并将next++
id *add(id obj)
{
    ASSERT(!full());
    unprotect();
    //1、先将next指向一个局部变量
    id *ret = next;  // faster than `return next-1` because of aliasing
    //2、将obj指针赋给next
    //3、给next++，也就是next以指针偏移的方式+1，这样很方便
    *next++ = obj;
    protect();
    return ret;
}

说明：

都比较简单，而且注释也说的很清楚了
需要注意的一点就是next占有8个字节，可以存储一个对象的地址，它就表示将要插入的下一个对象的位置
因此我们可以直接将插入的对象赋给next就插入成功了，之后再次将next++到达下一次对象插入的位置

2.3.4 autoreleaseFullPage()

源码：

//获取下一个没有填充满的页，一直查询到最后一页如果仍然满就新建一页
static __attribute__((noinline))
id *autoreleaseFullPage(id obj, AutoreleasePoolPage *page)
{
    // The hot page is full. 
    // Step to the next non-full page, adding a new page if necessary.
    // Then add the object to that page.
    ASSERT(page == hotPage());
    ASSERT(page->full()  ||  DebugPoolAllocation);

    do {
        //循环如果已经满了，就取下一页
        if (page->child) page = page->child;
        //如果没有child，也就是最后一页了，就新建一页
        else page = new AutoreleasePoolPage(page);
    } while (page->full());

    //设置为当前页
    setHotPage(page);
    //压栈对象
    return page->add(obj);
}

说明：

如果当前页已经充满了，就进入这个方法
有两个操作，循环判断下一页是否已满，如果未满就将这个页设置为当前页，并添加对象
如果已满，就继续找下一页，如果最后一页仍然满，就新建一页来添加对象

2.3.5 autoreleaseNoPage()

源码：

//新建第一页（此时没有页）
    static __attribute__((noinline))
    id *autoreleaseNoPage(id obj)
    {
        // "No page" could mean no pool has been pushed
        // or an empty placeholder pool has been pushed and has no contents yet
        ASSERT(!hotPage());

        bool pushExtraBoundary = false;
        if (haveEmptyPoolPlaceholder()) {
            // We are pushing a second pool over the empty placeholder pool
            // or pushing the first object into the empty placeholder pool.
            // Before doing that, push a pool boundary on behalf of the pool 
            // that is currently represented by the empty placeholder.
            pushExtraBoundary = true;
        }
        else if (obj != POOL_BOUNDARY  &&  DebugMissingPools) {
            // We are pushing an object with no pool in place, 
            // and no-pool debugging was requested by environment.
            _objc_inform("MISSING POOLS: (%p) Object %p of class %s "
                         "autoreleased with no pool in place - "
                         "just leaking - break on "
                         "objc_autoreleaseNoPool() to debug", 
                         objc_thread_self(), (void*)obj, object_getClassName(obj));
            objc_autoreleaseNoPool(obj);
            return nil;
        }
        else if (obj == POOL_BOUNDARY  &&  !DebugPoolAllocation) {
            // We are pushing a pool with no pool in place,
            // and alloc-per-pool debugging was not requested.
            // Install and return the empty pool placeholder.
            return setEmptyPoolPlaceholder();
        }

        // We are pushing an object or a non-placeholder'd pool.

        // Install the first page.
        //创建第一页
        AutoreleasePoolPage *page = new AutoreleasePoolPage(nil);
        //第一页设置为当前页
        setHotPage(page);
        
        // Push a boundary on behalf of the previously-placeholder'd pool.
        //既然创建的是第一页，就需要将边界对象压栈
        if (pushExtraBoundary) {
            page->add(POOL_BOUNDARY);
        }
        
        // Push the requested object or pool.
        //再压栈一个待release的对象
        return page->add(obj);
    }

说明：

可以看到该方法是用来创建第一页的，并且第一页设置为当前页
如果是第一页就需要添加边界对象，之后再压栈一个待release的对象
新建页是通过构造函数AutoreleasePoolPage实现的
在分析自动释放池的认识时已经知道其实是通过其父类的AutoreleasePoolPageData的构造函数来实现的

2.3.5 总结

自动释放池的结构以及添加对象过程.png

自动释放池由多张页组成，这些页通过以双向链表的形式组织，并且这个页的数据结构是栈，遵循先进后出原则

构造自动释放池其实就是创建第一页，页的创建是通过AutoreleasePoolPage的构造函数来创建的

构造函数中会将结构体中的成员添加到页中，如果是第一页，还需要添加边界对象

如果只有一页，第一页就是当前页

在添加对象时需要先把前面的页填满，再依此添加到后面的页，如果所有的页都满了，就再继续创建页

页的创建都是通过AutoreleasePoolPage的构造函数来实现的，但是除了第一页，其他页都没有边界对象

创建的页越迟，处在池子的位置越深

大小的计算：

一页有多大：
- 根据AutoreleasePoolPage结构体中的定义可知是4096个字节
一页的结构体成员有多大：根据父类AutoreleasePoolPageData的结构体的成员可知，成员大小为56个字节
- 属性magic 的类型是magic_t结构体，所占内存大小为m[4];所占内存（即4*4=16字节）
- 属性next（指针）、thread（对象）、parent（对象）、child（对象）均占8字节（即4*8=32字节）
- 属性depth、hiwat类型为uint32_t，实际类型是unsigned int类型，均占4字节（即2*4=8字节
一页的边界对象有多大
- 所有的对象其实都是指针形式存储的，所以是8个字节
一页存储的release对象有多少
- 前面可以看到每页总共有4096个字节，减去结构体成员的56个字节，还剩4040个字节，一个对象占有8个字节，所以可以存储505个对象。
- 而第一页会占有一个边界对象，所以这么说：第一页可以添加504个对象，其他页可以添加505个对象
depath如何计数：
- 每一页都有一个深度，表示该页在自动释放池中所处的位置。如果第一页表示没有深度，深度为0，如果是第二页深度为1

autorelease 底层分析

2.4 将对象添加到自动释放池的过程，也就是autorelease的过程

2.4.1 查看autorelease底层源码

代码：

__attribute__((aligned(16), flatten, noinline))
id
objc_autorelease(id obj)
{
    //如果不是对象，则直接返回
    if (!obj) return obj;
    //如果是小对象，也直接返回
    if (obj->isTaggedPointer()) return obj;
    return obj->autorelease();
}

说明：

可以看到其实就是调用autorelease()实现的

2.4.2 autorelease()

主要是通过autoreleaseFast函数实现对象的添加


👇
inline id 
objc_object::autorelease()
{
    ASSERT(!isTaggedPointer());
    //判断是否是自定义类
    if (fastpath(!ISA()->hasCustomRR())) {
        return rootAutorelease();
    }

    return ((id(*)(objc_object *, SEL))objc_msgSend)(this, @selector(autorelease));
}
👇
inline id 
objc_object::rootAutorelease()
{
    //如果是小对象，直接返回
    if (isTaggedPointer()) return (id)this;
    if (prepareOptimizedReturn(ReturnAtPlus1)) return (id)this;

    return rootAutorelease2();
}
👇
__attribute__((noinline,used))
id 
objc_object::rootAutorelease2()
{
    ASSERT(!isTaggedPointer());
    return AutoreleasePoolPage::autorelease((id)this);
}
👇

static inline id autorelease(id obj)
{
    ASSERT(obj);
    ASSERT(!obj->isTaggedPointer());//小对象类型不涉及
    id *dest __unused = autoreleaseFast(obj);//其实也就是添加一个对象的过程
    ASSERT(!dest  ||  dest == EMPTY_POOL_PLACEHOLDER  ||  *dest == obj);
    return obj;
}

说明：

通过一步一步找，最终找到是在AutoreleasePoolPage结构体中的autorelease函数实现的
最终是调用autoreleaseFast添加对象，这个前面已经分析过了，这里就不再分析了。

2.4 自动释放池释放的过程，也就是pop的过程

2.4.1 pop()

源码：

//出栈
static inline void
pop(void *token)
{
    AutoreleasePoolPage *page;
    id *stop;
   //判断对象是否是空占位符
    if (token == (void*)EMPTY_POOL_PLACEHOLDER) {
        //如果当是空占位符
        // Popping the top-level placeholder pool.
        //获取当前页
        page = hotPage();
        if (!page) {
            // Pool was never used. Clear the placeholder.
            //如果当前页不存在，则清除空占位符
            return setHotPage(nil);
        }
        // Pool was used. Pop its contents normally.
        // Pool pages remain allocated for re-use as usual.
        //如果当前页存在，则将当前页设置为coldPage,token设置为coldPage的开始位置
        page = coldPage();
        token = page->begin();
    } else {
        //获取token所在的页
        page = pageForPointer(token);
    }
    
    stop = (id *)token;
    //判断最后一个位置，是否是哨兵
    if (*stop != POOL_BOUNDARY) {
        //最后一个位置不是哨兵，即最后一个位置是一个对象
        if (stop == page->begin()  &&  !page->parent) {
            //如果是第一个位置，且没有父节点，什么也不做
            // Start of coldest page may correctly not be POOL_BOUNDARY:
            // 1. top-level pool is popped, leaving the cold page in place
            // 2. an object is autoreleased with no pool
        } else {
            //如果是第一个位置，且有父节点，则出现了混乱
            // Error. For bincompat purposes this is not 
            // fatal in executables built with old SDKs.
            return badPop(token);
        }
    }

    if (slowpath(PrintPoolHiwat || DebugPoolAllocation || DebugMissingPools)) {
        return popPageDebug(token, page, stop);
    }
    //出栈页
    return popPage<false>(token, page, stop);
}

说明：

如果当前页不存在，说明池子中已经没有页了，池子已空。
通过popPage将页删除

2.4.2 popPage()

源码：

//删除一页
template<bool allowDebug>
static void
popPage(void *token, AutoreleasePoolPage *page, id *stop)
{
    if (allowDebug && PrintPoolHiwat) printHiwat();

    //将该页的对象全部release
    page->releaseUntil(stop);

    // memory: delete empty children
    //如果该页是空的，就直接删除掉该页，并设置上一页为当前页
    if (allowDebug && DebugPoolAllocation  &&  page->empty()) {
        // special case: delete everything during page-per-pool debugging
        AutoreleasePoolPage *parent = page->parent;
        //删除该页
        page->kill();
        //设置上一页为当前页
        setHotPage(parent);
    //如果该页是空的，并且该页没有上一页，也就是该页是第一页，就清空自动释放池
    } else if (allowDebug && DebugMissingPools  &&  page->empty()  &&  !page->parent) {
        // special case: delete everything for pop(top)
        // when debugging missing autorelease pools
        page->kill();
        //表示自动释放池已没有页
        setHotPage(nil);
    //如果仍然有下一页，就先把下一页删掉
    } else if (page->child) {
        // hysteresis: keep one empty child if page is more than half full
        if (page->lessThanHalfFull()) {
            page->child->kill();
        }
        else if (page->child->child) {
            page->child->child->kill();
        }
    }
}

说明：

删除页，需要先将页中存储的对象删除掉
如果该页为空，直接删除，并且设置上一页为当前页
如果该页已经是第一页了，就说明池子已空，就清空池子
如果仍然有下一页，就先把下一页删掉

2.4.3 releaseUntil()

源码：

//释放到stop位置之前的所有对象
void releaseUntil(id *stop) 
{
    // Not recursive: we don't want to blow out the stack  不是递归的：我们不想破坏堆栈
    // if a thread accumulates a stupendous amount of garbage
    //判断下一个对象是否等于stop，如果不等于，则进入while循环
    while (this->next != stop) {
        // Restart from hotPage() every time, in case -release 
        // autoreleased more objects 每次从hotPage（）重新启动，以防-release自动释放更多对象
        //获取当前操作页面，即hot页面
        AutoreleasePoolPage *page = hotPage();

        // fixme I think this `while` can be `if`, but I can't prove it
        //如果当前页是空的
        while (page->empty()) {
            //将page赋值为父节点页
            page = page->parent;
            //并设置当前页为父节点页
            setHotPage(page);
        }

        page->unprotect();
        //next进行--操作，即出栈
        id obj = *--page->next;
        //将页索引位置置为SCRIBBLE，表示已经被释放
        memset((void*)page->next, SCRIBBLE, sizeof(*page->next));
        page->protect();

        if (obj != POOL_BOUNDARY) {
            //释放
            objc_release(obj);
        }
    }
    //设置当前页
    setHotPage(this);

#if DEBUG
    // we expect any children to be completely empty
    for (AutoreleasePoolPage *page = child; page; page = page->child) {
        ASSERT(page->empty());
    }
#endif
}

说明：

通过循环遍历，判断对象是否等于stop，其目的是释放stop之前的所有的对象
首先通过获取page的next释放对象（即page的最后一个对象），并对next进行递减，获取上一个对象
判断是否是哨兵对象，如果不是则自动调用objc_release释放

2.4.4 kill()

源码：

//删除页
void kill() 
{
    // Not recursive: we don't want to blow out the stack 
    // if a thread accumulates a stupendous amount of garbage
    AutoreleasePoolPage *page = this;
    //获取到最后一页
    while (page->child) page = page->child;

    AutoreleasePoolPage *deathptr;
    //从后往前，将每一页都置位nil，也就是删掉每一页
    do {
        deathptr = page;
        page = page->parent;
        if (page) {
            page->unprotect();
            page->child = nil;
            page->protect();
        }
        delete deathptr;
    } while (deathptr != this);
}

说明：

这里就是删掉每一页，从后向前删除
删除的方式就是设置为nil。

2.4.5 总结

自动释放池的删除是对页的删除，从后向前一页一页的删除，后一页删除就将前一页设置为当前页，一直删除到没有当前页说明池子已空

页的删除主要是对象的release，也是从后向前一个一个的执行objc_release操作，一直到边界对象，release完成

19 - 内存管理方案之自动释放池AutoRelease

1、自动释放池的认识

1.1 介绍

1.2 查看autoreleasePool的本质

2、底层分析

2.1 首先看下objc源码中是如何描述自动释放池的

2.2 自动释放池的认识

2.2.1 查看源码

2.2.2 AutoreleasePoolPage

2.2.3 AutoreleasePoolPageData

2.3 自动释放池的创建，也就是AutoreleasePoolPage的构造

2.3.1 push()

2.3.2 autoreleaseFast()

2.3.3 add()

2.3.4 autoreleaseFullPage()

2.3.5 autoreleaseNoPage()

2.3.5 总结

2.4 将对象添加到自动释放池的过程，也就是autorelease的过程

2.4.1 查看autorelease底层源码

2.4.2 autorelease()

2.4 自动释放池释放的过程，也就是pop的过程

2.4.1 pop()

2.4.2 popPage()

2.4.3 releaseUntil()

2.4.4 kill()

2.4.5 总结