iOS 深入探究 AutoreleasePool

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 的实现原理