AutoreleasePool 是什么

AutoreleasePool （下面称为缓存池）是 iOS 开发中的一种内存管理的机制，对象调用 autorelease 方法后会被放到缓存池中延迟释放，当缓存池需要清除时，会向这些 Autoreleased 对象发送 release 消息。

新建一个 Xcode 项目，将项目调整成 MRC:

在 MRC 中，需要使用 retain/release/autorelease 手动管理内存,如下代码：

int main(int argc, const char * argv[]) {
    NSLog(@"-A-");
    Coder *coder = [[Coder alloc] init];
    [coder release];
    NSLog(@"-B-");
    return 0;
}

// log
-A-
Coder dealloc
-B-

这里用 alloc 创建了 coder 对象，让它的引用计数增加，然后调用 release 方法完成释放。如果使用 autorelease，就需要用到自动缓存池了，代码如下：

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        NSLog(@"-A-");
        Coder *coder = [[[Coder alloc] init] autorelease];
        NSLog(@"-B-");
    }
    NSLog(@"-C-");
    return 0;
}

// log
-A-
-B-
Coder dealloc
-C-

这里的 coder 对象在出了自动缓存池的作用域后被自动释放。

不是所有情况都是出了作用域后自动释放，后面详解。

@autoreleasepool 干了什么

通过 xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc main.m 命令将 main.m 转成 C++ 代码。

会发现 @autoreleasepool 被转成一个成员变量：

__AtAutoreleasePool __autoreleasepool;

__AtAutoreleasePool 结构体的实现：

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

这里有一个 C++ 的语法，__AtAutoreleasePool() 是构造函数，创建结构体时调用，~__AtAutoreleasePool() 是析构函数，在结构体销毁时调用，所以上面的代码就可以理解为：

int main(int argc, const char * argv[]) {
    void *atautoreleasepoolobj = objc_autoreleasePoolPush();
    // @autoreleasepool 括号里面的代码
    objc_autoreleasePoolPop(atautoreleasepoolobj);
    return 0;
}

这也解释了上面说的为什么并不是所有情况都是出了 @autoreleasepool 作用域后自动释放，因为这只是一个语法糖，本质是调用了上面的 Push&PoP 方法。

AutoreleasePoolPage

runtime源码地址，这里使用的 objc4-723

在源码中查找上面的 Push&Pop 函数：

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

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

这里调用了 AutoreleasePoolPage 这个类的 Push&Pop 函数，关于 Push&Pop 这里先打住。先来看看 AutoreleasePoolPage 是怎样的结构，这里只有成员变量：

class AutoreleasePoolPage 
{
    magic_t const magic;
    id *next;
    pthread_t const thread;
    AutoreleasePoolPage * const parent;
    AutoreleasePoolPage *child;
    uint32_t const depth;
    uint32_t hiwat;
    // ...
}

这里的 next 指针指向的是最新被添加进来的 autorelease 对象的下一个位置。单看这个是不好理解的，所以这里直接先说 AutoreleasePoolPage。

自动释放池实际上是封装的 AutoreleasePoolPage 这个 C++ 类，以双向链表的形式构成。每个 AutoreleasePoolPage 对象会开辟 4096 字节内存（也就是虚拟内存一页的大小），除了上面的实例变量所占空间，剩下的空间全部用来以栈的方式储存 autorelease 对象。AutoreleasePoolPage 空间被占满时，会以链表的形式新建链接一个 AutoreleasePoolPage 对象，然后将 autorelease 对象的地址存在里面。如图所示：

源码分析

回到最初的 C++ 代码：

void *atautoreleasepoolobj = objc_autoreleasePoolPush();
objc_autoreleasePoolPop(atautoreleasepoolobj);

调用 Push 函数后，会获得一个返回值，这个返回值作为 Pop 函数的参数被传入了，下面来看看里面具体的原理是什么。直接来看 Push 函数的源码：

// 简化后
static inline void *push() 
{
    id *dest;
    dest = autoreleaseFast(POOL_BOUNDARY);
    return dest;
}

这里有个 POOL_BOUNDARY 值得我们注意，不过查看它的定义会发现它其实是等价 nil 的宏定义：

#   define POOL_BOUNDARY nil

也就是说，POOL_BOUNDARY 仅仅只是一个哨兵值。进入 autoreleaseFast(...) 函数：

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

hotPage 指当前使用的 AutoreleasePoolPage 节点，coldPage 指已经被装满的链表节点。

这里的判断逻辑完全符合前面关于 AutoreleasePoolPage 的说明：

1.当前 page 存在且没有满时，直接将对象添加到当前 page 中。
2.当前 page 存在且已满时，创建一个新的 page ，并将对象添加到新创建的 page 中，然后将这两个链表节点链接。
3.当前 page 不存在时，创建第一个 page ，并将对象添加到新创建的 page 中。

每次 Push 后，都会先添加一个 POOL_BOUNDARY 来占位，是为了对应一次 Pop 的释放，例如图中的 page 就需要两次 Pop 然后完全的释放。也就是代码中嵌套的情况：

@autoreleasepool {
    @autoreleasepool {

    }
}

这里还需要强调的是，这里使用的是双链表来实现，只有在当前 page 空间使用完后，才会创建新的 page，并不是每个 @autoreleasepool 对应一个 AutoreleasePoolPage 对象。

接下来看 Pop 的源码:

// 简化后
static inline void pop(void *token) 
{   
    AutoreleasePoolPage *page;
    id *stop;
    page = pageForPointer(token);
    stop = (id *)token;
    // 1.根据 token，也就是上文的占位 POOL_BOUNDARY 释放 `autoreleased` 对象
    page->releaseUntil(stop);

// hysteresis: keep one empty child if page is more than half full
    // 2.释放 `Autoreleased` 对象后，销毁多余的 page。
    if (page->lessThanHalfFull()) {
        page->child->kill();
    }
    else if (page->child->child) {
        page->child->child->kill();
    }
}

这里没什么说的，来到 releaseUntil(...) 内部：

// 简化后
void releaseUntil(id *stop) 
{
    // 1.
    while (this->next != stop) {
        AutoreleasePoolPage *page = hotPage();
        // 2.
        while (page->empty()) {
            page = page->parent;
            setHotPage(page);
        }
        // 3.
        if (obj != POOL_BOUNDARY) {
            objc_release(obj);
        }
    }
    // 4.
    setHotPage(this);
}

1.外部循环挨个遍历 autoreleased 对象，直到遍历到 stop 这个 POOL_BOUNDARY 。
2.如果当前 hatPage 没有 POOL_BOUNDARY，将 hatPage 设置为父节点。
3.给当前 autoreleased 对象发送 release 消息。
4.再次配置 hatPage。

再来看看 autorelease 的实现，这里直接定位到 page 里面的 autorelease:

// 简化后
static inline id autorelease(id obj)
{
    id *dest __unused = autoreleaseFast(obj);
    return obj;
}

和上面的 push 操作中调用的同一函数 autoreleaseFast，没什么说的。

这里从源码层面上就了解了自动缓存池道理是怎么一回事。

AutoreleasePool 和 runloop

这里需要 runloop 的知识，可以看我前面的文章 iOS 浅谈 Runloop

App 启动后，苹果在主线程 RunLoop 里注册了两个 Observer，回调都是 _wrapRunLoopWithAutoreleasePoolHandler ，用来处理自动缓存池。

打印主线程的 runloop 进行确认。

print(RunLoop.main)

注意观察图中 Observer 观察的状态，上面的是 activities = 0x1，下面的是 activities = 0xa0。这里需要一点 runloop 的知识，下面就是 runloop 可以被监听的状态枚举。

typedef CF_OPTIONS(CFOptionFlags, CFRunLoopActivity) {
    kCFRunLoopEntry = (1UL << 0),              // 1
    kCFRunLoopBeforeTimers = (1UL << 1),       // 2
    kCFRunLoopBeforeSources = (1UL << 2),      // 4
    kCFRunLoopBeforeWaiting = (1UL << 5),      // 32
    kCFRunLoopAfterWaiting = (1UL << 6),       // 64
    kCFRunLoopExit = (1UL << 7),               // 128
    kCFRunLoopAllActivities = 0x0FFFFFFFU
};

0x1 （等于1）对应的是 kCFRunLoopEntry ，第一个 Observer 监视的即将进入Loop时，，其回调内会调用 _objc_autoreleasePoolPush() 创建一个自动释放池。其 order 是 -2147483647，优先级最高，保证创建缓存池发生在其他所有回调之前。

0xa0（16进制等于160，等于32+128）对应的是 kCFRunLoopBeforeWaiting&kCFRunLoopExit，第二个 Observer 监视了两个事件：准备进入休眠时调用 _objc_autoreleasePoolPop() 和 _objc_autoreleasePoolPush() 释放旧的池并创建新池；即将退出Loop时调用 _objc_autoreleasePoolPop() 来释放自动释放池。这个 Observer 的 order 是 2147483647，优先级最低，保证其释放缓存池发生在其他所有回调之后。

所以对于我们应用来说，autoreleased 对象更多的是在 runloop 的休眠时进行释放的。

参考

关于 AutoreleasePool 还有一些实际使用中的技巧，例如解决循环中 autoreleased 对象的内存问题等等。

黑幕背后的Autorelease

Objective-C Autorelease Pool 的实现原理