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