[iOS] AutoreleasePool实现原理

AutoreleasePool自动释放池,是 OC 中的一种内存自动回收机制,可以将加入自动释放池中的对象的release 时机延迟。当自动释放池作用域结束时,将池中的对象统一发送一次 release 消息,当对象的引用计数为零时,对象就会被释放。

我们这次来探究一下AutoreleasePool自动释放池的实现原理!

1. AutoreleasePool底层结构

在 main.m 编写如下函数:

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

通过clang -rewrite-objc main.m 指令,将 main.m 转化为main.cpp文件,自动释放池部分代码如下:

extern "C" __declspec(dllimport) void * objc_autoreleasePoolPush(void);
extern "C" __declspec(dllimport) void objc_autoreleasePoolPop(void *);

struct __AtAutoreleasePool {
  // 构造函数
  __AtAutoreleasePool() {atautoreleasepoolobj = objc_autoreleasePoolPush();}
  // 析构函数
  ~__AtAutoreleasePool() {objc_autoreleasePoolPop(atautoreleasepoolobj);}
  // 成员变量
  void * atautoreleasepoolobj;
};

#define __OFFSETOFIVAR__(TYPE, MEMBER) ((long long) &((TYPE *)0)->MEMBER)
int main(int argc, char * argv[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 

    }
    return 0;
}

上面的代码很清晰,自动释放池构造时,会调用objc_autoreleasePoolPush()函数,销毁时会调用objc_autoreleasePoolPop()函数。

对应 objc 中的源码实现为:

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

NEVER_INLINE
void
objc_autoreleasePoolPop(void *ctxt)
{
    AutoreleasePoolPage::pop(ctxt);
}


void *
_objc_autoreleasePoolPush(void)
{
    return objc_autoreleasePoolPush();
}

void
_objc_autoreleasePoolPop(void *ctxt)
{
    objc_autoreleasePoolPop(ctxt);
}

可以看到,自动释放池构造时调用AutoreleasePoolPage::push()函数,析构时调用 AutoreleasePoolPage::pop(ctxt);函数。下面也会从这两个函数为切入点进行分析。

AutoreleasePoolPage类实现的上方有一段注释,翻译如下:

  • 一个线程的自动释放池就是一个存放对象指针的栈(AutoreleasePool的结构是由AutoreleasePoolPage作为节点构成的双向链表,而每个AutoreleasePoolPage里面有一个存放对象指针的)。
  • 栈里面的每个指针要么是等待autorelease的对象,要么是POOL_BOUNDARY自动释放池边界(实际为#define POOL_BOUNDARY nil,同时也是 next 的指向)。一个pool token是指向 POOL_BOUNDARY 的指针。
    -AutoreleasePoolPage 会根据需要进行动态添加和删除。
  • hotPage 保存在当前线程中,当有新的autorelease 对象添加进自动释放池时会被添加到hotPage

先大概理解一下,下面继续看下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
... 方法实现先省略
}

从源码中可以看出AutoreleasePoolPage 是私有继承自AutoreleasePoolPageData的类,并且页的大小为 4096字节,保存的 autorelease 对象的指针,每个指针占 8 个字节(后面会进行验证)。

我们继续看下AutoreleasePoolPageData,是一个结构体:

class AutoreleasePoolPage;
struct AutoreleasePoolPageData
{
    magic_t const magic; //用来校验AutoreleasePoolPage的结构是否完整
    __unsafe_unretained id *next; // 作为游标指向栈顶最新 add 进来的 autorelease 对象的下一个位置
    pthread_t const thread; // AutoreleasePool是按线程一一对应的,thread 是自动释放池所处的线程
    AutoreleasePoolPage * const parent; // 指向前面的节点
    AutoreleasePoolPage *child;  // 指向后面的节点
    uint32_t const depth; // 标记每个结点在链表中的深度,第一个节点为 0,后面依次递增
    uint32_t hiwat;

      // 构造函数
    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)
    {
    }
};

AutoreleasePoolPageData结构体中可以看出,其包含构成双向链表的两个指针parentchild,所以说明自动释放池确实是一个双向链表结构。

AutoreleasePoolPageData结构体占用的内存大小为56个字节(这个点在下面会体现到):
-magic的类型是 magic_t结构体,成员变量只有uint32_t m[4];,占用 4 * 4 = 16字节

  • next、thread 、parent、child均占8字节,即4 * 8 = 32字节
  • 属性depth、hiwat类型为uint32_t,实际类型是unsigned int类型,均占4字节(即2 * 4 = 8字节)

大概是下图这样的结构:

image.png

其中的56个字节存储的AutoreleasePoolPage的成员变量,其他的区域存储加载到自动释放池的对象。
next==begin()时表示AutoreleasePoolPage为空,当next==end()的时表示AutoreleasePoolPage已满。

大概了解了AutoreleasePool的结构之后,我们就从objc_autoreleasePoolPush方法开始进行分析。

2. objc_autoreleasePoolPush源码分析

objc_autoreleasePoolPush方法,内部是调用了AutoreleasePoolPage::push()方法,源码如下:

//入栈
static inline void *push() 
{
    id *dest;
    // OPTION( DebugPoolAllocation, OBJC_DEBUG_POOL_ALLOCATION,
    // "halt when autorelease pools are popped out of order, 
    // and allow heap debuggers to track autorelease pools")
    // 当自动释放池弹出顺序时停止,并允许堆调试器跟踪自动释放池

    if (slowpath(DebugPoolAllocation)) {
        // Each autorelease pool starts on a new pool page.自动释放池从新池页面开始
        // 创建一个新的自动释放池
        dest = autoreleaseNewPage(POOL_BOUNDARY);
    } else {
        // 压栈一个POOL_BOUNDARY,即压栈哨兵
        dest = autoreleaseFast(POOL_BOUNDARY);
    }
    ASSERT(dest == EMPTY_POOL_PLACEHOLDER || *dest == POOL_BOUNDARY);
    return dest;
}

从源码中可以看出,如果自动释放池不存在,则构建一个新的pagepush 函数的作用可以理解为,调用AutoreleasePoolPage::push在当前线程的存储空间保存一个 EMPTY_POOL_PLACEHOLDER

autoreleaseFast 函数比autoreleaseNewPage多了一个判断page还没有满时就直接添加 objpage中的逻辑,剩下的调用autoreleaseFullPageautoreleaseNoPage 是一样的。

2.1 autoreleaseNewPage函数

autoreleaseNewPage函数源码如下:

static __attribute__((noinline))
    id *autoreleaseNewPage(id obj)
    {
        // 获取当前操作的page
        AutoreleasePoolPage *page = hotPage();
        // 如果存在则压栈对象
        if (page) return autoreleaseFullPage(obj, page);
        // 如果不存在则创建页
        else return autoreleaseNoPage(obj);
    }
2.2 hotPage

获取当前的页,hotPage是在线程中存储的,代码如下:

static inline AutoreleasePoolPage *hotPage() 
    {
        AutoreleasePoolPage *result = (AutoreleasePoolPage *)
            tls_get_direct(key);
        // 如果是一个空池,则返回nil,否则,返回当前线程的自动释放池
        if ((id *)result == EMPTY_POOL_PLACEHOLDER) return nil;
        if (result) result->fastcheck();
        return result;
    }
2.3 autoreleaseFullPage

page 满了的时候,就会调用autoreleaseFullPage方法,主要是构建新的AutoreleasePoolPage,添加进双向链表中,并把obj添加进去,代码如下:

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.
    // 如果 hotpage 满了,转到下一个未满的 page,如果不存在的话添加一个新的 page。  
    // 然后把 object 添加到新 page 里。
    
    // page 必须是 hotPage
    ASSERT(page == hotPage());
    // page 满了,或者自动释放池按顺序弹出时暂停,并允许堆调试器跟踪自动释放池
    
    // OPTION( DebugPoolAllocation,
    //         OBJC_DEBUG_POOL_ALLOCATION,
    //         "halt when autorelease pools are popped out of order,
    //          and allow heap debuggers to track autorelease pools")
    // 自动释放池按顺序弹出时暂停,并允许堆调试器跟踪自动释放池
    
    ASSERT(page->full()  ||  DebugPoolAllocation);

    // do while 循环里面分为两种情况
    // 1. 沿着 child 往后走,如果能找到一个非满的 page,则可以把 obj 放进去
    // 2. 如果 child 不存在或者所有的 child 都满了,
    //    则构建一个新的 AutoreleasePoolPage 并拼接在 AutoreleasePool 的双向链表中,
    //    并把 obj 添加进新 page 里面
    do {
        if (page->child) page = page->child;
        // 构造方法时传进的page的child会指向新构建的page,也就是添加新构建的page到双向链表中
        else page = new AutoreleasePoolPage(page);
    } while (page->full());

    // 设置 page 为 hotPage
    setHotPage(page);
    
    // 把 obj 添加进 page 里面,返回值是 next 之前指向的位置 (objc_object **)
    return page->add(obj);
}

其中 page->add(obj)是将obj 压入栈中:

id *add(id obj)
    {
        ASSERT(!full());
        unprotect();
        id *ret = next;  // faster than `return next-1` because of aliasing
        *next++ = obj;
        protect();
        return ret;
    }
2.4 autoreleaseNoPage

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
    // "No page" 可能意味着没有构建任何池,或者只有一个 EMPTY_POOL_PLACEHOLDER 占位
    
    // hotPage 不存在,否则执行断言
    ASSERT(!hotPage());

    bool pushExtraBoundary = false;
    if (haveEmptyPoolPlaceholder()) {
        // 如果线程里面存储的是 EMPTY_POOL_PLACEHOLDER
        
        // 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) {
        // OPTION( DebugMissingPools, OBJC_DEBUG_MISSING_POOLS,
        // "warn about autorelease with no pool in place, which may be a leak")
        // 警告在没有自动释放池的情况下进行 autorelease,
        // 这可能导致内存泄漏(可能是因为没有释放池,然后对象缺少一次 objc_release 执行,导致内存泄漏)
        // 如果 obj 不为 nil 并且 DebugMissingPools。
        
        // We are pushing an object with no pool in place,
        // and no-pool debugging was requested by environment.
        // 我们正在没有自动释放池的情况下把一个对象往池里推,
        // 并且打开了 environment 的 no-pool debugging,此时会在控制台给一个提示信息。
        
        // 线程内连 EMPTY_POOL_PLACEHOLDER 都没有存储,并且如果 DebugMissingPools 打开了,则控制台输出如下信息
        _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));
                     
        // obj 不为 nil,并且线程内连 EMPTY_POOL_PLACEHOLDER 都没有存储
        // 执行 objc_autoreleaseNoPool,且它是个 hook 函数             
        objc_autoreleaseNoPool(obj);
        
        // 返回 nil
        return nil;
    }
    else if (obj == POOL_BOUNDARY  &&  !DebugPoolAllocation) {
        // OPTION( DebugPoolAllocation, OBJC_DEBUG_POOL_ALLOCATION, 
        //         "halt when autorelease pools are popped out of order, 
        // and allow heap debuggers to track autorelease pools")
        // 当自动释放池顺序弹出时暂停,并允许堆调试器跟踪自动释放池
        // 如果 obj 为空,并且没有打开 DebugPoolAllocation
        
        // We are pushing a pool with no pool in place,
        // and alloc-per-pool debugging was not requested.
        // 在没有池的情况下,我们设置一个空池占位,并且不要求为池分配空间和调试。(空池占位只是一个 ((id*)1))
        
        // Install and return the empty pool placeholder.
        
        // 根据 key 在当前线程的存储空间内保存 EMPTY_POOL_PLACEHOLDER 占位
        return setEmptyPoolPlaceholder();
    }

    // We are pushing an object or a non-placeholder'd pool.
    // 构建非占位的池

    // Install the first page.
    // 构建自动释放池的第一个真正意义的 page
    
    AutoreleasePoolPage *page = new AutoreleasePoolPage(nil);
    
    // 设置为 hotPage
    setHotPage(page);
    
    // Push a boundary on behalf of the previously-placeholder'd pool.
    // 代表先前占位符的池推边界。
    
    // 如果之前有一个 EMPTY_POOL_PLACEHOLDER 在当前线程的存储空间里面占位的话
    if (pushExtraBoundary) {
        // 池边界前进一步
        
        // 可以理解为把 next 指针往前推进了一步,并在 next 之前的指向下放了一个 nil 
        page->add(POOL_BOUNDARY);
    }
    
    // Push the requested object or pool.
    // 把 objc 放进自动释放池
    return page->add(obj);
}

这个方法主要是在线程中创建一个EMPTY_POOL_PLACEHOLDER占位,然后创建自动释放池的第一页,并且将哨兵对象压进栈中。

其中AutoreleasePoolPage的创建是通过其构造方法实现的,它的构造方法其实是AutoreleasePoolPageData的构造方法:

//**********AutoreleasePoolPage构造方法**********
    AutoreleasePoolPage(AutoreleasePoolPage *newParent) :
        AutoreleasePoolPageData(begin(),//开始存储的位置
                                objc_thread_self(),//传的是当前线程,当前线程时通过tls获取的
                                newParent,
                                newParent ? 1+newParent->depth : 0,//如果是第一页深度为0,往后是前一个的深度+1
                                newParent ? newParent->hiwat : 0)
{ 
    if (parent) {
        parent->check();
        ASSERT(!parent->child);
        parent->unprotect();
        //this 表示 新建页面,将当前页面的子节点 赋值为新建页面
        parent->child = this;
        parent->protect();
    }
    protect();
}

//**********AutoreleasePoolPageData初始化方法**********
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)
    {
    }

上面 begin()表示压栈的位置,即下一个要释放对象的压栈地址,其实就是页的首地址 + 56,这个56其实就是结构体AutoreleasePoolPageData本身所占用的内存大小,在上面我们已经计算过了。

2.2 autoreleaseFast

代码实现如下:

static inline id *autoreleaseFast(id obj)
    {
        AutoreleasePoolPage *page = hotPage();
        if (page && !page->full()) {
            return page->add(obj);
        } else if (page) {
            return autoreleaseFullPage(obj, page);
        } else {
            return autoreleaseNoPage(obj);
        }
    }

主要是判断当前页是否满了,如果没满,则直接添加,如果满了则开辟新页,如果当前页都没有,再进入autoreleaseNoPage的流程。

2.3 自动释放池内存结构

在分析了objc_autoreleasePoolPush之后,我们对于自动释放池有了个大概的认识,现在我们通过代码去验证下他的结构:
由于在ARC模式下,是无法手动调用autorelease,所以将Demo切换至MRC模式(Build Settings -> Objectice-C Automatic Reference Counting设置为NO):

image.png

定义如下代码:

//************打印自动释放池结构************
extern void _objc_autoreleasePoolPrint(void);

//************运行代码************
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        //循环创建对象,并加入自动释放池
        for (int i = 0; i < 5; i++) {
             NSObject *objc = [[NSObject alloc] sutorelease];
        }
        //调用
        _objc_autoreleasePoolPrint();
    }
}

运行结果如下,发现是 6 个,但是我们实际上创建了 5个对象啊,其中的POOL表示哨兵,即边界,其目的是为了防止越界,也就是我们在上面autoreleaseNoPage方法中添加的POOL_BOUNDARY:

image.jpeg

从上图中我们看到,page 的首地址是0x100817000 和 哨兵对象的地址0x100817038相差0x38 ,转换成十进制刚好是56,也就是AutoreleasePoolPage本身所占用的大小,想想上面的 begin()方法,也是从首地址 + 56 开始存储的。

在一开始我们还提到 page的大小为 4096 字节,自身占用了56个字节,哨兵对象占用了8个字节,所以除去哨兵对象还能存储 4032 / 8 = 504个对象,我们将上述的测试代码的循环次数数据改为 505,其内存结构如下,发现第一页满了,存储了504个要释放的对象,第二页只存储了一个 ,说明是对的:

image.png

我们将数据改为505 + 506,来验证第二页是否也是存储 505个对象:

image.jpeg

可以发现,第一页存储了504 个,第二页存储了 505个,第三页存储了2 个。

所以通过上述测试,可以得出以下结论:

  • 第一页可以存放 504 个对象,且只有第一页有哨兵对象,当第一页满了,就会开辟新的页
  • 第二页开始,最多可以存放505个对象
  • 一页的大小 = 505 * 8 + 56 = 4096 字节

自动释放池结构如下图所示:


image.png
2.4. autorelease底层分析

在 demo 中,我们通过 autorelease方法,在MRC的模式下,将对象压栈到自动释放池,会调用objc_autorelease方法,源码如下:

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

进入对象的autorelease实现:


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());
    //autoreleaseFast 压栈操作
    id *dest __unused = autoreleaseFast(obj);
    ASSERT(!dest  ||  dest == EMPTY_POOL_PLACEHOLDER  ||  *dest == obj);
    return obj;
}

从这里看出,无论是压栈哨兵对象,还是普通对象,都会来到autoreleaseFast方法,只是区别标识不同。

2.5 总结

autoreleaseobjc_autoreleasePush的整体流程如下图所示:

image.png

3. objc_autoreleasePoolPop 源码分析

objc_autoreleasePoolPop方法中有个参数,在clang分析时,发现传入的参数是push压栈后返回的对象,即ctxt,其目的是避免出栈混乱,防止将别的对象出栈:

static inline void
pop(void *token)
{
    AutoreleasePoolPage *page;
    id *stop;

    if (token == (void*)EMPTY_POOL_PLACEHOLDER) {
        // Popping the top-level placeholder pool.
        // 弹出顶级 EMPTY_POOL_PLACEHOLDER 占位符池
        
        // 取出 hotPage
        page = hotPage();
        if (!page) {
            // 如果 hotPage 不存在,则表示目前就一 EMPTY_POOL_PLACEHOLDER,说明池还没有使用过
            // Pool was never used. Clear the placeholder.
            // Pool 从未使用过。清除占位符。
            return setHotPage(nil);
        }
        // Pool was used. Pop its contents normally.
        // Pool 是使用过了。正常弹出其内容。
        // Pool pages remain allocated for re-use as usual.
        // Pool pages 保持分配以照常使用.
        
        // 第一个 page
        page = coldPage();
        // 把第一个 page 的 begin 赋值给 token
        token = page->begin();
    } else {
        // token 转为 page 
        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);
        }
    }
    
    // allowDebug 为 true
    if (slowpath(PrintPoolHiwat || DebugPoolAllocation || DebugMissingPools)) {
        return popPageDebug(token, page, stop);
    }
    
    // 释放对象删除 page
    return popPage(token, page, stop);
}


进入popPage源码,其中传入的allowDebugfalse,则通过releaseUntil出栈当前页stop位置之前的所有对象,即向栈中的对象发送release消息,直到遇到传入的哨兵对象:

//出栈页面
template
    static void
    popPage(void *token, AutoreleasePoolPage *page, id *stop)
{
    if (allowDebug && PrintPoolHiwat) printHiwat();
    //出栈当前操作页面对象
    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
        //特殊情况:调试丢失的自动释放池时删除pop(top)的所有内容
        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();
        }
    }
}

进入releaseUntil实现,主要是通过循环遍历,判断对象是否等于stop,其目的是释放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
        
        // 循环从 next 开始,一直后退,直到 next 到达 stop
        while (this->next != stop) {
            // Restart from hotPage() every time, in case -release 
            // autoreleased more objects
            
            // 取得当前的 AutoreleasePoolPage
            AutoreleasePoolPage *page = hotPage();

            // fixme I think this `while` can be `if`, but I can't prove it
            // fixme 我认为 “while” 可以是 “if”,但我无法证明
            // 我觉得也是可以用 if 代替 while
            // 一个 page 满了会生成一个新的 page 并链接为下一个 page,
            // 所以从第一个 page 开始到 hotPage 的前一个page,应该都是满的
            
            // 如果当前 page 已经空了,则往后退一步,把前一个 AutoreleasePoolPage 作为 hotPage
            while (page->empty()) {
                // 当前 page 已经空了,还没到 stop,
                // 往后走 
                page = page->parent;
                // 把 page 作为 hotPage
                setHotPage(page);
            }
            
            // 可读可写
            page->unprotect();
            
            // next 后移一步,并用解引用符取出 objc_object * 赋值给 obj
            id obj = *--page->next;
            
            // 把 page->next 开始的 sizeof(*page->next) 个字节置为 SCRIBBLE
            memset((void*)page->next, SCRIBBLE, sizeof(*page->next));
            
            // 只可读
            page->protect();
            
            // 如果 obj 不为 nil,则执行 objc_release 操作
            if (obj != POOL_BOUNDARY) {
                objc_release(obj);
            }
        }

        // 这里还是把 this 作为 hotPage,
        // 可能从 stop 所在的 page 开始到 hotPage 这些 page 本来存放自动释放对象的位置都放的是 SCRIBBLE
        setHotPage(this);

#if DEBUG
        // we expect any children to be completely empty
        // 保证从当前 page 的 child 开始,向后都是空 page
        for (AutoreleasePoolPage *page = child; page; page = page->child) {
            ASSERT(page->empty());
        }
#endif
    }


从最前面的page开始一直向后移动直到到达stop 所在的 page,并把经过的page里保存的对象都执行一次 objc_release操作,把之前每个存放 objc_object ** 的空间都置为 SCRIBBLE,每个pagenext 都指向了该 pagebegin

release做的事情是遍历释放保存的自动释放对象,而kill 做的事情是遍历对 AutoreleasePoolPage 执行 delete操作:

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;
    // 从当前 page 开始一直沿着 child 链往前走,直到 AutoreleasePool 的双向链表的最后一个 page
    while (page->child) page = page->child;

    // 临时变量(死亡指针)
    AutoreleasePoolPage *deathptr;
    
    // 是 do while 循环,所以会至少进行一次 delete,
    // 即当前 page 也会被执行 delete(不同与上面的 release 操作,入参 stop 并不会执行 objc_release 操作)
    do {
        // 要执行 delete 的 page
        deathptr = page;
        
        // 记录前一个 page
        page = page->parent;
        
        // 如果当前 page 的 parent 存在的话,要把这个 parent 的 child 置为 nil
        // 这个是链表算法题的经典操作
        if (page) {
            // 可读可写
            page->unprotect();
            
            // child 置为 nil
            page->child = nil;
            
            // 可写
            page->protect();
        }
        
        // delete page
        delete deathptr;
    } while (deathptr != this);
}


从当前的page 开始,一直根据 child 链向前走直到 child为空,把经过的page全部执行delete 操作(包括当前page)。

pthread_exit线程退出时,触发了_pthread_tsd_cleanup,触发AutoreleasePoolPagetls_dealloc(void*),然后回收autorelease对象:

static void tls_dealloc(void *p) 
{
    // # define EMPTY_POOL_PLACEHOLDER ((id*)1)
    // 如果 p 是空占位池则 return
    if (p == (void*)EMPTY_POOL_PLACEHOLDER) {
        // No objects or pool pages to clean up here.
        // 这里没有 objects 或者 pages 需要清理
        return;
    }

    // reinstate TLS value while we work
    // 这里直接把 p 保存在 TLS 中作为 hotPage
    setHotPage((AutoreleasePoolPage *)p);

    if (AutoreleasePoolPage *page = coldPage()) {
        // 如果 coldPage 存在(双向链表中的第一个 page)
        
        // 这个调用的函数链超级长,最终实现的是把自动释放池里的所有自动释放对象都执行
        // objc_release 然后所有的 page 执行 delete 
        if (!page->empty()) objc_autoreleasePoolPop(page->begin());  // pop all of the pools
        
        // OPTION( DebugMissingPools, 
        //         OBJC_DEBUG_MISSING_POOLS,
        //         "warn about autorelease with no pool in place, which may be a leak")
        // 警告没有池的自动释放,这可能是泄漏
        
        // OPTION( DebugPoolAllocation,
        //         OBJC_DEBUG_POOL_ALLOCATION,
        //         "halt when autorelease pools are popped out of order,
        //          and allow heap debuggers to track autorelease pools")
        // 当自动释放池顺序弹出时暂停,并允许堆调试器跟踪自动释放池
        
        if (slowpath(DebugMissingPools || DebugPoolAllocation)) {
            // pop() killed the pages already
        } else {
            // 从 page 开始一直沿着 child 向前把所有的 page 执行 delete
            // kill 只处理 page,不处理 autorelease 对象
            page->kill();  // free all of the pages
        }
    }
    
    // clear TLS value so TLS destruction doesn't loop
    // 清除 TLS 值,以便 TLS 销毁不会循环
    // 把 hotPage 置为 nil
    // static pthread_key_t const key = AUTORELEASE_POOL_KEY;
    // tls_set_direct(key, (void *)page);
    // 把 key 置为 nil
    setHotPage(nil);
}

综上所述,objc_autoreleasePoolPop出栈的流程如下所示:

image.png

4. AutoreleasePool和RunLoop

一般很少会将自动释放池RunLoop联系起来,但是如果打印[NSRunLoop currentRunLoop]结果中会发现和自动释放池相关的回调。

{valid = Yes, activities = 0xa0, repeats = Yes, order = 2147483647, callout = _wrapRunLoopWithAutoreleasePoolHandler (0x7fff48c1235c), context = {type = mutable-small, count = 1, values = (0 : <0x7fc18f80e038>)}}
{valid = Yes, activities = 0x1, repeats = Yes, order = -2147483647, callout = _wrapRunLoopWithAutoreleasePoolHandler (0x7fff48c1235c), context = {type = mutable-small, count = 1, values = (0 : <0x7fc18f80e038>)}}

即App启动后,苹果会给RunLoop注册很多个observers,其中有两个是跟自动释放池相关的,其回调都是_wrapRunLoopWithAutoreleasePoolHandler()

第一个observer监听的是activities=0x1(kCFRunLoopEntry),也就是在即将进入loop时,其回调会调用_objc_autoreleasePoolPush()创建自动释放池;
第二个observer监听的是activities = 0xa0(kCFRunLoopBeforeWaiting | kCFRunLoopExit)
即监听的是准备进入睡眠和即将退出loop两个事件。在准备进入睡眠之前,因为睡眠可能时间很长,所以为了不占用资源先调用_objc_autoreleasePoolPop()释放旧的释放池,并调用_objc_autoreleasePoolPush()创建新建一个新的,用来装载被唤醒后要处理的事件对象;在最后即将退出loop时则会_objc_autoreleasePoolPop()释放池子。

你可能感兴趣的:([iOS] AutoreleasePool实现原理)