自动释放池

自动释放池 是 OC 的一种 内存自动回收机制。它可以延迟加入 AutoreleasePool 中的变量 release 的时机，即当我们创建了一个对象，并把他加入到了自动释放池中时，他不会立即被释放，会等到一次 runloop 结束或者作用域超出 {} 或者超出 [pool release] 之后再被释放。下面我们通过三种方式分别来解析

Clang 分析

创建一个空工程，切换到 main.m 文件

#import <UIKit/UIKit.h>
#import "AppDelegate.h"

int main(int argc, char * argv[]) {
    NSString * appDelegateClassName;
    @autoreleasepool {
        // Setup code that might create autoreleased objects goes here.
        appDelegateClassName = NSStringFromClass([AppDelegate class]);
    }
    return UIApplicationMain(argc, argv, nil, appDelegateClassName);
}

通过终端命令 clang -x objective-c -rewrite-objc -isysroot /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator14.2.sdk main.m 导出 cpp 文件，打开 main.cpp 文件，查看 main 函数的实现源码

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

        appDelegateClassName = NSStringFromClass(((Class (*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("AppDelegate"), sel_registerName("class")));
    }
    return UIApplicationMain(argc, argv, __null, appDelegateClassName);
}

// __AtAutoreleasePool 结构体
struct __AtAutoreleasePool {
  __AtAutoreleasePool() {
      atautoreleasepoolobj = objc_autoreleasePoolPush();
  }
  ~__AtAutoreleasePool() {
      objc_autoreleasePoolPop(atautoreleasepoolobj);
  }
  void * atautoreleasepoolobj;
};

从上面源码中看到，__AtAutoreleasePool 是一个结构体，有 构造函数 + 析构函数，结构体定义的对象在作用域结束后，会自动调用析构函数。本质也是一个对象

@autoreleasepool {}
//等价于
{__AtAutoreleasePool __autoreleasepool; }

汇编分析

在 main 函数中打个断点，运行程序，开启汇编模式

通过调试的结果发现，跟 clang 分析的结果一致

底层分析

关于 AutoreleasePool，在 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.
   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.
   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. 
**********************************************************************/

• 1. 线程的自动释放池是指针的堆栈。
• 2. 每个指针都是要释放的对象（或者是 POOL_BOUNDARY，POOL_BOUNDARY 是自动释放池的边界）。
• 3. 一个自动释放池的标示是指向该池的 POOL_BOUNDARY 的指针。 当自动释放池出栈，将释放比哨兵更热的每个对象。
• 4. 堆栈被分为一个双向链接的页面列表（page）。 根据需要添加和删除页面。
• 5. 线程本地存储指向热页面，该页面存储新自动释放的对象。

自动释放池是什么时候创建的？对象是如何加入自动释放池的？哪些对象才会加入自动释放池？带着这些疑问，我们来一步步探索自动释放池的底层原理

AutoreleasePoolPage

我们根据前面 clang 以及汇编的分析，自动释放池的底层是调用了 objc_autoreleasePoolPush 和 objc_autoreleasePoolPop 两个方法，我们进入 objc781 查看其源码实现，如下：

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

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

从上面的源码中我们看到，两个方法走的分别是 AutoreleasePoolPage 的 push 和 pop 实现，那么进入 AutoreleasePoolPage 的源码看下是如何定义的

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(),
                                newParent,
                                newParent ? 1+newParent->depth : 0,
                                newParent ? newParent->hiwat : 0) {...}

    // 析构函数
    ~AutoreleasePoolPage(){...}
    
    ...

    // 添加释放对象
    id *add(id obj) {...}

    //释放所有对象
    void releaseAll() {...}
    
    ...

    // 获取AutoreleasePoolPage
    static AutoreleasePoolPage *pageForPointer(const void *p) {...}
    static AutoreleasePoolPage *pageForPointer(uintptr_t p) {...}

    ...

    // 获取当前操作页
    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) {...}

    // 创建新的page
    static __attribute__((noinline))
    id *autoreleaseNewPage(id obj) {...}

public:
    // 自动释放
    static inline id autorelease(id obj) {...}


    //入栈
    static inline void *push() {...}
    
    ...

    // 出栈
    static inline void
    pop(void *token) {...}

    ...
    
#undef POOL_BOUNDARY
};

从 AutoreleasePoolPage 定义发现，它是一个 page，同时也是一个 对象，这个页的大小为 4096 字节。AutoreleasePoolPage 继承自 AutoreleasePoolPageData，那么它的结构是什么样呢？如下

class AutoreleasePoolPage;
struct AutoreleasePoolPageData
{
    // 用来校验 AutoreleasePoolPage 的结构是否完整
    magic_t const magic;
    // 指向最新添加的 autoreleased 对象的下一个位置，初始化时指向 begin()
    __unsafe_unretained id *next;
    // 指向当前线程
    pthread_t const thread;
    // 指向父节点，第一个结点的 parent 值为 nil
    AutoreleasePoolPage * const parent;
    // 指向子节点，最后一个结点的 child 值为 nil
    AutoreleasePoolPage *child;
    // 表示深度，从 0 开始，往后递增 1
    uint32_t const depth;
    // 表示 high water mark 最大入栈数量标记
    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 结构看到了 AutoreleasePoolPage，这里也间接的证明了自动释放池是一个 双向链表的页 结构。

AutoreleasePoolPageData 的内存大小为 56 字节，magic_t 结构体占用内存为 m[4]，占内存为 16 字节（4*4）；属性 next（指针）、thread（对象）、parent（对象）、child（对象） 均占 8 字节，共 32 字节；uint32_t 两个各占 4 字节，共 8字节。

objc_autoreleasePoolPush

通过上面的分析，我们进入 AutoreleasePoolPage 的 push 实现，如下

static inline void *push()
{
    id *dest;
    if (slowpath(DebugPoolAllocation)) { //1.
        // Each autorelease pool starts on a new pool page.
        dest = autoreleaseNewPage(POOL_BOUNDARY); //2.
    } else {
        dest = autoreleaseFast(POOL_BOUNDARY);//3.
    }
    ASSERT(dest == EMPTY_POOL_PLACEHOLDER || *dest == POOL_BOUNDARY);
    return dest;
}

• 1. 判断是否创建过 pool
• 2. 没有，创建一个新的 page
• 3. 压栈一个 POOL_BOUNDARY（哨兵）

1. autoreleaseNewPage（创建新的页）

首先需要判断 hotPage（当前页）是否存在，执行后续操作

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

// 获取当前操作页（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;
}

• 如果存在 hotpage，则通过 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;
        // 子页面不存在，则新建
        else page = new AutoreleasePoolPage(page);
    } while (page->full());

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

通过操作 child 对象，将当前页的 child 指向新建页面，建立双向链表连接

• 如果不存在 hotpage，通过 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;
    // 判断是否是空占位符，如果是，则压栈哨兵标识符置为YES
    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;
    }
    // 如果对象不是哨兵对象，而且没有 Pool，则报错
    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);
    // 设置 page 为当前操作页
    setHotPage(page);
    
    // Push a boundary on behalf of the previously-placeholder'd pool.
    // 压栈哨兵的标识符为YES，则压栈哨兵对象
    if (pushExtraBoundary) {
        // 压栈哨兵对象
        page->add(POOL_BOUNDARY);
    }
    
    //压栈对象
    // Push the requested object or pool.
    return page->add(obj);
}

当前页面不存在或者子页面不存在时，通过 AutoreleasePoolPage 的构造方法创建新的 AutoreleasePoolPage，而它的构造方法实现是通过 AutoreleasePoolPageData 的初始化方法来的

/**AutoreleasePoolPage 的构造方法*/
AutoreleasePoolPage(AutoreleasePoolPage *newParent) :
    AutoreleasePoolPageData(begin(), // 开始存储的位置
                            objc_thread_self(), // 传的是当前线程，当前线程时通过 tls 获取的
                            newParent, 
                            newParent ? 1+newParent->depth : 0,
                            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 的内存大小）

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

• objc_thread_self() 表示当前线程，而当前线程时通过 tls 获取的

__attribute__((const))
static inline pthread_t objc_thread_self()
{
    // 通过tls获取当前线程
    return (pthread_t)tls_get_direct(_PTHREAD_TSD_SLOT_PTHREAD_SELF);
}

• newParent 表示的是 AutoreleasePoolPageData 的父节点

• newParent ? 1+newParent->depth : 0 表示通过父节点的深度计算 depth

• newParent ? newParent->hiwat : 0 表示通过父节点的最大入栈个数计算 hiwat

• add 方法

添加释放对象，其底层是实现是通过 next 指针存储释放对象，并将 next 指针递增，表示下一个释放对象存储的位置。从这里可以看出页是通过栈结构存储

id *add(id obj)
{
    ASSERT(!full());
    unprotect();
    
    // 传入对象存储的位置
    id *ret = next;  // faster than `return next-1` because of aliasing
    // 将obj压栈到next指针位置，然后next进行++，即下一个对象存储的位置
    *next++ = obj;
    protect();
    return ret;
}

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

3. 自动释放池内存结构

在 ARC 模式下，是无法手动调用 autorelease，所以要将项目切换至 MRC 模式 Build Settings -> Objective-C Automatic Reference Counting 设置为 NO

• 在 main.m 中添加如下代码

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

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

运行项目，打印结果如下

从打印结果我们看到有 6 个对象，但是我们压栈的对象是 5 个，另一个其实是前面说到的哨兵对象（边界），目的是为了防止越界。另外，从地址的打印，我们也看到了哨兵对象与首地址相差了 0x38（十进制 56）刚好就是 AutoreleasePoolPage（继承自 AutoreleasePoolPageData） 所占的内存大小。

• 将上述的 for 循环改为 505次，再次运行项目，查看它的打印结果

从打印结果可以看到，第一页已经存满了，存储了 504 个 需要释放的对象，第二页存储了一个对象，如果我们将 for 循环次数改为 1010 个呢？

通过运行发现，第一页存储 504 个，第二页存储 505 个，第三页存储 1 个

自动释放池第一页可以存放 1 个哨兵对象（有且只有一个，且在第一页）加 504 个需要释放的对象，当一页压栈满了，就会开辟新的一页，从第二页开始可以存放最多 505 个对象（一页的大小为 505*8 = 4040 字节）

同样这个结论可以通过 AutoreleasePoolPage 中 SIZE 来验证，定义中 PAGE_MIN_SIZE 大小为 4096 字节，在其构造函数中对象的压栈位置 begin() 是从 首地址+56 字节开始的，所以在一个 page 中实际可以存储 4096-56 = 4040 字节，转换成对象 4040/8 = 505 个，因为第一页有哨兵对象，最多存储 504 个

objc_autoreleasePoolPop

在 objc-781 源码中我们看到 objc_autoreleasePoolPop 实现源码中有个参数，这个参数在 clang 分析中可以找到，在 objc_autoreleasePoolPush() 返回一个 atautoreleasepoolobj （哨兵对象），即 ctxt。其目的是为了避免出栈混乱。

• 进入 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);
}

• 1. 空白页处理/根据token获取page
• 2. 容错处理
• 3. popPage 出栈

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

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

    // 当前操作页面出栈
    page->releaseUntil(stop);

    // memory: delete empty children
    // 特殊情况处理 allowDebug 传入为 fasle
    if (allowDebug && DebugPoolAllocation  &&  page->empty()) {
        // special case: delete everything during page-per-pool debugging
        // 获取当前页面的父节点
        AutoreleasePoolPage *parent = page->parent;
        // 将当前页面 kill
        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 实现，源码如下

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
        // 获取当前操作页
        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;
        // 将已开辟内存空间 page->next 的首 sizeof(*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
}

• 1. 通过 do-while 循环，判断对象是否等于 stop，目的是释放 stop 之前的所有需要释放的对象
• 2. 判空处理
• 3. 通过获取 page 的 next 对象，标记已被释放状态
• 4. 判断是否是哨兵对象，如果不是则自动调用 objc_release 释放

下面我们进入 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;
    // 获取最后一个 page
    while (page->child) page = page->child;

    AutoreleasePoolPage *deathptr;
    do {
        deathptr = page;
        // 当前页的子节点变为父节点
        page = page->parent;
        if (page) {
            page->unprotect();
            // 将父节点页的子节点变为 nil
            page->child = nil;
            page->protect();
        }
        delete deathptr;
    } while (deathptr != this);
}

主要是销毁当前页，将当前页赋值为父节点页，并将父节点页的 child 对象指针置为 nil

autorelease 源码分析

上面我们知道了 autoreleasepool 的底层原理，下面我们来看下 autorelease 的底层实现，如下，我们打开汇编看下 autorelease 的底层调用（因为 Xcode 默认是 ARC 模式，不能调用 autorelease，需要开启 MRC 模式）

打开 objc781 源码，我们进入 objc_autorelease 的源码，如下

__attribute__((aligned(16), flatten, noinline))
id
objc_autorelease(id obj)
{
    // 如果不是对象，直接返回
    if (!obj) return obj;
    // 如果是 Tagged Pointer，直接返回
    if (obj->isTaggedPointer()) return obj;
    return obj->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()
{
    // 如果是 Tagged Pointer，返回
    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;
    }

无论是压栈哨兵对象，还是普通对象，都会来到 autoreleaseFast方法，只是区别标识不同而以

总结

通过以上的分析，针对自动释放池的 push 以及 pop，做个总结

objc_autoreleasePoolPush

• 1. 判断有没有 pool，即只有空占位符（存储在tls中）时，创建页，并压栈哨兵对象
• 2. 压栈对象，通过 page->add(obj) 方法，将 next 指针递增
• 3. 当页面满了，设置当前操作页的 child 为新建页，并设置新建页为当前操作页，压栈对象

push 流程图

objc_autoreleasePoolPop

• 1. 在页中出栈，主要是通过 next 指针递减实现
• 2. 当页空了时，赋值页的 parent 为当前操作页，并将新的当前操作页的 child 设置为 nil

pop 流程图