autoreleasePool实现原理详解

在我们平时开发中，经常会涉及到对象的使用，但我们往往都不知道我们所开辟的对象是在何时被回收的，有没有及时的被释放，在苹果引入ARC之后，平时书写OC代码的时候都很少对内存释放做过处理，但是有一些场景还是需要我们手动去管理内存的释放；比如大量的for循环创建对象时候，比如子线程中存在持续性任务没办法及时关闭，这个时候也要我们手动管理临时变量的释放；

概念：对象执行 autorelease 方法或者直接在 autoreleasePool 中创建对象，会将对象添加到 autoreleasePool 中，当自动释放池销毁的时候，会对所有对象做 release 操作；

创建autoreleasePool

MRC环境创建：

   // 1、生成一个NSAutoreleasePool对象
    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
    // 2、调用autorelease方法
    id object = [[NSObject alloc] init];
    [object autorelease];
    // 3、对象销毁
    [pool drain];

ARC环境创建：

@autoreleasepool {
     //LLVM
     id object = [NSArray array];
}

MRC环境下，我们创建的对象需要调用autorelease添加到自动释放池中，而ARC环境下，我们只要通过@autoreleasepool就可以；

通过查找源码会发现，ARC内部其实已经帮我们自动实现了autorelease方法，帮我们添加到autoreleasePool中；

#ifndef AUTORELEASE
/**
 *  Basic autorelease operation ... calls [NSObject-autorelease]

 *  Does nothing when ARC is in use.
 */
#define AUTORELEASE(object) [(id)(object) autorelease]
#endif

接下来就是分析autoReleasePool内部具体的工作原理；
因为main入口函数就为我们提供了一个现成的autoReleasePool

所以可以直接通过clang得到编译后的内容，找到autoReleasePool

clang main.m -rewrite-objc

会发现@autoreleasepool本质上就是帮我们生成一个__AtAutoreleasePool对象

通过检索__AtAutoreleasePool会发现，它其实就是一个结构体，里面包含了两个函数，一个构造函数，一个析构函数；当autoreleasepool初始化的时候就会调用__AtAutoreleasePool()构造函数，当作用域离开的时候就会调用析构函数~__AtAutoreleasePool();

构造函数就是通过objc_autoreleasePoolPush()生成atautoreleasepoolobj对象，析构函数就是调用objc_autoreleasePoolPop函数，把atautoreleasepoolobj传递进去，这时候我们发现，我们应该重点分析的方法是objc_autoreleasePoolPush及objc_autoreleasePoolPop；

这个时候就得查看官方源码了；

objc_autoreleasePoolPush

在NSObject.mm定位到objc_autoreleasePoolPush，内部是直接调用了AutoreleasePoolPage的push方法；

到这里又引出了新的类-->AutoreleasePoolPage，进一步观察会发现它是继承自AutoreleasePoolPageData；

进入AutoreleasePoolPageData，会发现AutoreleasePoolPage其实是个双向链表，里面包含parent指针跟child指针，指向前后两个page节点；

接下来我们就来探索一下push方法的实现；点击去看会发现push其实就是静态内联函数，

push方法里面判断自动释放池AutoreleasePoolPage是否初始化过了，初始化过了就调用autoreleaseFast，否则就调用autoreleaseNewPage初始化一个新的page，观察发现这两个方法里面都传入了一个POOL_BOUNDARY参数，这个又是什么呢？？

#   define POOL_BOUNDARY nil

点击去看会发现POOL_BOUNDARY是一个nil，这个就有点懵了，传进去nil有何意义？？？

POOL_BOUNDARY

POOL_BOUNDARY其实是一个哨兵对象也可以看成一个边界，用来分割不同的@autoreleasepool；

我们有时候会为了代码的可读性，或使用多层@autoreleasepool的嵌套，这些autoreleasepool会用同一个AutoreleasePoolPage对象。以下面的三个嵌套为例，在同一个page中的顺序是下图这样。不同的@autoreleasepool以POOL_BOUNDARY做分割。

@autoreleasepool {
    NSObject *p1 = [[NSObject alloc] init];
    NSObject *p2 = [[NSObject alloc] init];
    @autoreleasepool {
        NSObject *p3 = [[NSObject alloc] init];
        @autoreleasepool {
            NSObject *p4 = [[NSObject alloc] init];
        }
    }
}

autoreleaseFast

接下来分析一下autoreleaseFast方法，在函数内部，通过hotPage获取当前的page，

1、如果page存在并且page有存储空间，就调用add方法将对象存到page中；

2、如果page存在但是没有存储空间，这个时候就调用autoreleaseFullPage函数创建新的page，并且将链表的末尾指向新创建的page。

3、如果没有page不存在，则调用autoreleaseNoPage函数创建一个新的page；

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);
        }
    }

add

add函数核心逻辑就是将obj放入next指针的位置，并且对next指针进行++，指向下一个位置。*next++表示先用后加，先将obj存入next的地址，随后+1；用ret保存next的地址，即上一个对象地址，并返回；

id *add(id obj) {
    ASSERT(!full());
    unprotect();
    id *ret = next;  
    *next++ = obj;
    protect();
    return ret;
}

这里又引发一个问题，next指针刚开始指向哪里呢？？？

通过进一步探索会发现，begin即this(即当前page的首地址)加上当前结构体的需要占用的内存空间，即自动释放池第一个对象从这里开始存储；

    id * begin() {
        return (id *) ((uint8_t *)this+sizeof(*this));
    }

    id * end() {
        return (id *) ((uint8_t *)this+SIZE);
    }

    bool empty() {
        return next == begin();
    }

    bool full() { 
        return next == end();
    }

简单画了一个流程粗略表示一个obj对象入栈的过程；

自动释放池push过程

那么每一个page能存储多少空间呢？

从最新的源码中可以看出，SIZE最大可以是PAGE_MAX_SIZE是1按位左移14，即end指针指向2^14+this；

autoreleaseFullPage

1. 在autoreleaseFullPage函数中，会从page的链表中，从前往后找到末尾的节点child。

2. 创建一个新的page，在创建函数AutoreleasePoolPage中会对parent和child指针做处理，返回的page可以直接用。

3. 调用setHotPage将page设置到tls_set_direct哈希表中，tls_set_direct(key, (void *)page); 标记成当前可用的page；并且调用page的add函数将autorelease修饰的对象，添加到page中。

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;
            else page = new AutoreleasePoolPage(page);
        } while (page->full());

        setHotPage(page);
        return page->add(obj);
    }

autoreleaseNoPage

autoreleaseNoPage函数的核心代码其实比较简单，就是创建一个新的page，并且也是一样，调用setHotPage设置当前可供使用的page；随后设置POOL_BOUNDARY哨兵对象，并且把对象添加进去。

static __attribute__((noinline))
    id *autoreleaseNoPage(id obj)
    {
        // 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.
        return page->add(obj);
    }

objc_autoreleasePoolPop

分析完push的流程之后，接下来就分析一下pop的流程，即自动释放池释放的过程；

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

objc_autoreleasePoolPop函数内部其实也是用到AutoreleasePoolPage对象，只是调用pop函数；

pop

1. 判断autoreleasepool是否为空，通过EMPTY_POOL_PLACEHOLDER占位符判断，为空则清空这个page。

2. autoreleasepool不为空，则调用pageForPointer方法，对传入的指针token取模，p % SIZE，再用p减去偏移量offset，拿到result返回给page使用，这个表示当前token在最后一个page上的位置；

3. 传入的stop是否不等于POOL_BOUNDARY标识，如果不等于则可能是一个有问题的page。

4. 调用popPage方法，释放对象。

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.
            page = coldPage();
            token = page->begin();
        } else {
            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(token, page, stop);
    }

static AutoreleasePoolPage *pageForPointer(uintptr_t p) {
        AutoreleasePoolPage *result;
        uintptr_t offset = p % SIZE;

        ASSERT(offset >= sizeof(AutoreleasePoolPage));

        result = (AutoreleasePoolPage *)(p - offset);
        result->fastcheck();

        return result;
    }

popPage

接下来就是探索一下popPage如何释放对象；

1. popPage内部核心代码就是执行releaseUntil方法进行释放操作；

2. 按照page达到一半就扩容的原则，后面的if语句会判断执行pop后page链表的状态。

   1. 如果少于半满，就将子节点删除。

   2. 如果大于半满，则保留子节点，并删除后面的节点。

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
            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

在releaseUntil函数内部，核心逻辑是从当前page，从后到前调用objc_release，释放被autorelease修饰的对象。

1. AutoreleasePoolPage *page = hotPage()，获取当前的hotPage。

2. 判断page是否为空，如果为空则表示里面的对象被释放完，则将page的父节点page设置为hotPage。

3. 获得上一个节点，->的算数优先级比--要高，所以是先通过next获取当前节点地址，这是一个为空的待存入节点，随后执行--操作获取上一个对象地址，跟前文提到的*next++ = obj有异曲同工之妙；

4. 通过memset将上一个节点释放。

5. 判断上一个节点是否占位符号POOL_BOUNDARY，如果不是则调用objc_release释放对象。

6. 在while循环结束后，将当前page设置为hotPage。

    void releaseUntil(id *stop) 
    {
        // Not recursive: we don't want to blow out the stack 
        // if a thread accumulates a stupendous amount of garbage

        while (this->next != stop) {
            // Restart from hotPage() every time, in case -release 
            // autoreleased more objects
            AutoreleasePoolPage *page = hotPage();

            // fixme I think this `while` can be `if`, but I can't prove it
            while (page->empty()) {
                page = page->parent;
                setHotPage(page);
            }

            page->unprotect();
#if SUPPORT_AUTORELEASEPOOL_DEDUP_PTRS
            AutoreleasePoolEntry* entry = (AutoreleasePoolEntry*) --page->next;

            // create an obj with the zeroed out top byte and release that
            id obj = (id)entry->ptr;
            int count = (int)entry->count;  // grab these before memset
#else
            id obj = *--page->next;
#endif
            memset((void*)page->next, SCRIBBLE, sizeof(*page->next));
            page->protect();

            if (obj != POOL_BOUNDARY) {
#if SUPPORT_AUTORELEASEPOOL_DEDUP_PTRS
                // release count+1 times since it is count of the additional
                // autoreleases beyond the first one
                for (int i = 0; i < count + 1; i++) {
                    objc_release(obj);
                }
#else
                objc_release(obj);
#endif
            }
        }

        setHotPage(this); 
    }

hotPage、coldPage概念

hotPage

hotPage可以被理解为最后一个可插入对象的page，即链表的末尾的page，当我们获取hotPage => AutoreleasePoolPage *page = hotPage() 以及setHotPage时，都是对链表末尾的page进行操作；

hotPage函数内部本质上是一个page和key的映射。通过当前的AUTORELEASE_POOL_KEY存取；

static pthread_key_t const key = AUTORELEASE_POOL_KEY;
static inline AutoreleasePoolPage *hotPage() {
        AutoreleasePoolPage *result = (AutoreleasePoolPage *)tls_get_direct(key);
        if ((id *)result == EMPTY_POOL_PLACEHOLDER) return nil;
        if (result) result->fastcheck();
        return result;
    }

通过tls_get_direct获取当前的page，这个tls其实就是thread local storage哈希表，即从当前线程的局部私有存储空间中取出该数据，只有当前线程才能访问的数据，这里就可以看出，autoreleasepool跟当前线程其实是有一定的对应关系，每个线程都有其对应的autoreleasepool，AutoreleasePoolPage对象和线程一一对应，；

coldPage

coldPage就是查询函数，通过查询链表page的根节点

static inline AutoreleasePoolPage *coldPage() 
    {
        AutoreleasePoolPage *result = hotPage();
        if (result) {
            while (result->parent) {
                result = result->parent;
                result->fastcheck();
            }
        }
        return result;
    }

page释放时机

下面这段主要参考探秘AutoreleasePool实现原理

被autorelease修饰的对象，释放时机有两种。

1. 如果通过代码添加一个autoreleasepool，在作用域结束时，随着pool的释放，就会释放pool中的对象。这种情况是及时释放的，并不依赖于runloop。

2. 另一种就是由系统自动进行释放，系统会在runloop开始的时候创建一个pool，结束的时候会对pool中的对象执行release操作

runloop

如果是系统创建的pool，需要手动开启runloop，主线程默认已经开启并运行，子线程需要调用currentRunLoop方法开启并运行runloop，子线程中系统创建pool的流程才会正常工作。

包括主线程在内的每个线程，如果在线程中使用到了AutoreleasePool，则会创建两个Observer并添加到当前线程的Runloop中，通过这两个Observer进行对象的自动内存管理。

// activities = 0x1，kCFRunLoopEntry
{valid = Yes, activities = 0x1, repeats = Yes, order = -2147483647, callout = _wrapRunLoopWithAutoreleasePoolHandler (0x10eee6276)}
// activities = 0xa0，kCFRunLoopBeforeWaiting | kCFRunLoopExit
{valid = Yes, activities = 0xa0, repeats = Yes, order = 2147483647, callout = _wrapRunLoopWithAutoreleasePoolHandler (0x10eee6276)}

首先会创建一个Observer并监听kCFRunLoopEntry消息，时机是在进入Runloop前，此Observer的优先级设置为-2147483647的最高优先级，以保证回调发生在Runloop其他事件前。

然后创建另一个Observer，并监听kCFRunLoopBeforeWaiting和kCFRunLoopExit消息，时机分别在进入Runloop休眠和退出Runloop时，将Observer的优先级设置为2147483647，以保证回调发生在Runloop其他事件之后。

两个Observer都有相同的回调函数_wrapRunLoopWithAutoreleasePoolHandler，在第一次回调时会在内部调用_objc_autoreleasePoolPush函数，创建自动释放池。

在kCFRunLoopBeforeWaiting将要进入休眠前，调用_objc_autoreleasePoolPop函数释放自动释放池中的对象，并调用_objc_autoreleasePoolPush函数创建一个新的释放池。在kCFRunLoopExit将要退出Runloop时调用_objc_autoreleasePoolPop函数，释放自动释放池中的对象。

对象添加到自动释放池过程

讲完了autoreleasePool的开辟跟回收过程，以及回收时机，最后对象添加到自动释放池过程

前文已经提到了，系统LLVM会在帮我们自动的调用一个autorelease方法，我们就顺着这个方法看看，它是如何一步步的插入到自动释放池中的；

-(id) autorelease
{
    return _objc_rootAutorelease(self);
}

NEVER_INLINE id
_objc_rootAutorelease(id obj)
{
    ASSERT(obj);
    return obj->rootAutorelease();
}

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->isTaggedPointerOrNil());
        id *dest __unused = autoreleaseFast(obj);
#if SUPPORT_AUTORELEASEPOOL_DEDUP_PTRS
        ASSERT(!dest  ||  dest == EMPTY_POOL_PLACEHOLDER  ||  (id)((AutoreleasePoolEntry *)dest)->ptr == obj);
#else
        ASSERT(!dest  ||  dest == EMPTY_POOL_PLACEHOLDER  ||  *dest == obj);
#endif
        return obj;
    }

1、autorelease先调用_objc_rootAutorelease方法

2、_objc_rootAutorelease内部在调用当前对象的rootAutorelease方法

3、rootAutorelease方法内部再调用当前对象的rootAutorelease2方法

4、rootAutorelease2方法在调用AutoreleasePoolPage::autorelease方法；

5、AutoreleasePoolPage::autorelease方法最后是调用autoreleaseFast，这个时候就跟我们分析autoreleasePush中的方法遥相呼应了；

总结就是：objc_object::autorelease >> objc_object::_objc_rootAutorelease >> _objc_rootAutorelease >> objc_object::rootAutorelease >> objc_object::rootAutorelease2 >> AutoreleasePoolPage::autorelease >> AutoreleasePoolPage::autoreleaseFast

注：
ARC的规则：alloc/new/copy/mutableCopy 开头的方法返回的对象不是 autorelease 对象；在我们平时开发中，不要出现alloc/new/copy/mutableCopy 开头的方法，否则很容易会导致内存泄露；