1.autorelease对象在什么时机会调用release？
（1）自动释放池它主要底层数据结构式__AtautoreleasePool，AtautoreleasePoolPage
调用了Atautorelease的对象最终都是通过AtautoreleasePoolPage对象来管理的
（2）很多人说, 当程序执行到作用域结束的位置时(当前作用域大括号结束时)，自动释放池就会被释放，这个说法是不对的。iOS的运行时是由一个一个runloop组成的，每个runloop中都创建一个Autorelease Pool，并在runloop的末尾进行释放，所以，一般情况下，每个接受autorelease消息的对象，都会在下个runloop开始前被释放。也就是说，在一段同步的代码中执行过程中，生成的对象接受autorelease消息后，一般是不会在作用域结束前释放的。
（3）所以严谨的说, 在没有手动添加Autorelease Pool的情况下，Autorelease对象是在当前的runloop迭代结束时释放的，而它能够释放的原因是系统在每个runloop迭代中都加入了自动释放池Push和Pop。
2.@autoreleasepool {} 干了些什么?
main.m 文件代码：
int main(int argc, const char * argv[]) {
@autoreleasepool {}
return 0;
}
使用 clang -rewrite-objc main.m 查看经过编译器前端处理的代码：
struct __AtAutoreleasePool {
__AtAutoreleasePool() {atautoreleasepoolobj = objc_autoreleasePoolPush();}
~__AtAutoreleasePool() {objc_autoreleasePoolPop(atautoreleasepoolobj);}
void * atautoreleasepoolobj;
};
int main(int argc, const char * argv[]) {
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; }
return 0;
}
可以看出@autoreleasepool{}会创建一个__AtAutoreleasePool类型的局部变量并包含在当前作用域，__AtAutoreleasePool构造和析构时分别调用了两个方法，所以简化过程如下：
void *context = objc_autoreleasePoolPush()
// 对象调用 autorelease 装入自动释放池
objc_autoreleasePoolPop(context)
可以猜测 push 和 pop 操作是实现自动释放的关键。
3.AutoreleasePoolPage 内存分布
官方文档[1]中提到了，主线程以及非显式创建的线程（比如 GCD）都会有一个 event loop (RunLoop 就是具体实现)，在 loop 的每一个循环周期的开始和结束会分别调用自动释放池的 push 和 pop 方法，由此来实现自动的内存管理。由此也可以确定，自动释放池是与线程一一对应的。
objc_autoreleasePoolPush()和objc_autoreleasePoolPop(...)实际上会调用到AutoreleasePoolPage类的push()和pop()方法，先看一下这个类的数据结构：
class AutoreleasePoolPage {
...
magic_t const magic;
id *next;
pthread_t const thread;
AutoreleasePoolPage * const parent;
AutoreleasePoolPage *child;
static void * operator new(size_t size) {
return malloc_zone_memalign(malloc_default_zone(), SIZE, SIZE);
}
id * begin() {
return (id *) ((uint8_t *)this+sizeof(*this));
}
id * end() {
return (id *) ((uint8_t *)this+SIZE);
}
...
}
- parent和child正是指向前驱和后继指针，自动释放池就是一个以AutoreleasePoolPage为节点的双向链表（后文验证）。
- thread是指当前 page 所对应的线程。
- magic用于校验内存是否损坏。
- next指向当前可插入对象的地址。
内存对齐
重写了new运算符，使用了malloc_zone_memalign(...)进行内存分配：
extern void *malloc_zone_memalign(malloc_zone_t *zone, size_t alignment, size_t size) ;
/*
* Allocates a new pointer of size size whose address is an exact multiple of alignment.
* alignment must be a power of two and at least as large as sizeof(void *).
* zone must be non-NULL.
*/
注释说得很清楚了，这个方法以alignment对齐的地址分配size的内存空间。调用时两个参数都使用了SIZE宏，实际上就是虚拟内存页的大小：
#define I386_PGBYTES 4096
一个 page 的内存空间设置过小会导致更多的开辟空间操作降低效率，大量的parent/child指针变量也会占用可观的内存；空间设置过大可能会导致一个 page 的利用率低浪费过多内存。设置为 4096 是比较考究的，在保证内存对齐的情况下最大化利用空间避免内存碎片。这么做过后 page 的地址总是 4096 的整数倍，可以让某些运算更便捷（比如后文会说的通过指针地址寻找对应的 page）。
begin() 与 end()
AutoreleasePoolPage本身的大小远不及 4096，而超出的空间正是用来存放“期望被自动管理的对象”。begin()和end()方法标记了这个范围。
sizeof(*this)表示AutoreleasePoolPage本身的大小，那么(uint8_t )this+sizeof(this)就是最低地址，(uint8_t *)this+SIZE就是最高地址。逐个插入对象时，next指针从begin()到end()逐个移动，后面的full()方法就是指next == end()，empty()就是指next == begin()。
值得注意的是next/end()/begin()等都是id *类型的，即指向指针的指针，进行 +1 -1 运算时移动的是一个id大小的距离。
4. push 逻辑
push()方法会调用autoreleaseFast(POOL_BOUNDARY)：
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);
}
}
hotPage 指的是当前可插入对象的 page，放到后面一点分析，先来看插入对象的逻辑，分三种情况：
- 当 page 存在且没满时，直接添加对象：
id *add(id obj)
{
assert(!full());
unprotect();
id *ret = next; // faster than `return next-1` because of aliasing
*next++ = obj;
protect();
return ret;
}
unprotect()/protect()内部使用了int mprotect(void *a, size_t b, int c)，设置内存起点a长度b的内存区域为c类型的访问限制：
inline void protect() {
#if PROTECT_AUTORELEASEPOOL
mprotect(this, SIZE, PROT_READ);
check();
#endif
}
inline void unprotect() {
#if PROTECT_AUTORELEASEPOOL
check();
mprotect(this, SIZE, PROT_READ | PROT_WRITE);
#endif
}
unprotect()设置为可读可写，protect()设置为只读，所以这里的目的是保证 page 写安全。不过有#define PROTECT_AUTORELEASEPOOL 0定义说明目前版本还没有开放这个保护功能。
- 当 page 存在且满了时，拓展 page 节点并添加对象：
static __attribute__((noinline))
id *autoreleaseFullPage(id obj, AutoreleasePoolPage *page)
{ ...
do {
if (page->child) page = page->child;
else page = new AutoreleasePoolPage(page);
} while (page->full());
setHotPage(page);
return page->add(obj);
}
循环的逻辑：从 child 方向找到未满的 page，若找不到则创建一个新 page 拼接到链表尾部（AutoreleasePoolPage 构造方法会把传入的 page 参数作为 parent 前驱对象）。后面再设置最新的 page 为 hotpage 并将 obj 添加进 page。
- 当 page 不存在时，初始化一个
static __attribute__((noinline))
id *autoreleaseNoPage(id obj)
{ ...
AutoreleasePoolPage *page = new AutoreleasePoolPage(nil);
setHotPage(page);
...
return page->add(obj);
}
这个方法核心就是创建第一个 page 然后加入线程局部存储。
hotPage
从上面的push()方法分析可知，被自动管理的对象会不断插入双向链表从前到后第一个未满 page ，hotPage()其实就是指向这个 page，还有个coldPage()方法是根据hotPage()找到第一个 page。
既然自动释放池是由AutoreleasePoolPage组成的双向链表，那这个链表该如何访问呢？可能常规的思路是创建一个全局变量来访问它，不过这里使用了另外一个方式：
static inline AutoreleasePoolPage *hotPage()
{
AutoreleasePoolPage *result = (AutoreleasePoolPage *)
tls_get_direct(key);
// EMPTY_POOL_PLACEHOLDER 表示没有 page
if ((id *)result == EMPTY_POOL_PLACEHOLDER) return nil;
if (result) result->fastcheck();
return result;
}
static inline void setHotPage(AutoreleasePoolPage *page)
{
if (page) page->fastcheck();
tls_set_direct(key, (void *)page);
}
tls_get_direct(...)和tls_set_direct(...)内部就是使用线程的局部存储（TLS: Thread Local Storage）将 page 存储起来，这样可以避免维护额外的空间来记录尾部的 page。由此也验证了自动释放池与线程一一对应的关系。
在 YYKit 中有一个使用广泛的技巧：将某个对象最后使用时放在异步线程，如果这个对象释放就（可能?）会在这个异步线程，从而降低主线程压力。实际上就是编译器插入 autorelease 代码将对象加入到异步线程的自动释放池，而如果异步线程的释放池先于主线程的释放池pop()而调用对象的release()方法，那么这个对象如果释放就会在异步线程。所以笔者认为这个优化并非绝对有效（这里衍生出一个问题：一个对象被多个自动释放池管理，若对象释放这些释放池怎么避免的野指针问题？）。
POOL_BOUNDARY
push()方法调用autoreleaseFast(POOL_BOUNDARY)时传入的是一个 POOL_BOUNDARY 并非需要被管理的对象，它的定义如下：
# define POOL_BOUNDARY nil
在调用autoreleaseFast(obj)方法会返回指向obj指针的指针，它是一个id *类型，也就是说，这个返回值关心的只是obj指针的地址，而不是obj值的地址，obj指针的地址就是对应AutoreleasePoolPage对象内存中的某段区域。
再看一下上层调用：
void *context = objc_autoreleasePoolPush()
...
objc_autoreleasePoolPop(context)
pop 时会将这个obj指针的地址传入进去。pop 的逻辑是把 hotPage 里面装的对象依次移除并发送 release 消息（后面会详细分析），当前 page 移除完了，继续移除 parent 节点内的对象，以此反复，而移除对象操作何时停止就是到这个obj指针的地址。
所以，push 操作加入一个 POOL_BOUNDARY 实际上就是加一个边界，pop 操作时根据边界判断范围，这就是一个入栈与出栈的过程。
magic 校验
多次出现的check()方法如下：
void check(bool die = true) {
if (!magic.check() || !pthread_equal(thread, pthread_self())) busted(die);
}
void fastcheck(bool die = true) {
//补充：#define CHECK_AUTORELEASEPOOL (DEBUG)
#if CHECK_AUTORELEASEPOOL
check(die);
#else
if (! magic.fastcheck()) busted(die);
#endif
}
可以看到，它们都调用了magic的 check 方法，在 DEBUG 时还会去检查当前线程是否与 page 的线程一致。
magic是magic_t类型的，这个结构体主要是有个uint32_t m[4];数组，构造时内存直接会写为0xA1A1A1A1 AUTORELEASE!，然后check()逻辑就是判断构造时的值是否发生了改变，若发生改变说明这个 page 已经被破坏。
5.autorelease 逻辑
上层对象调用 autorelease 方法会调用到AutoreleasePoolPage的以下方法：
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(...)方法进行对象插入。由此也可以推断，在一个 Thread 没有 Runloop 自动执行自动释放池的 push 和 pop 时，对象进行 autorelease 时若发现没有自动释放池节点会自动创建 page 并加入线程局部存储（参考前面的autoreleaseNoPage(...)方法分析）。
6.pop 逻辑
objc_autoreleasePoolPop(context)的context参数是objc_autoreleasePoolPush()返回的，实际上就是POOL_BOUNDARY对应的在AutoreleasePoolPage中的地址。最终会调用到pop()方法：
static inline void pop(void *token)
{
AutoreleasePoolPage *page;
id *stop;
...
// 拿到 token 边界对应的 page
page = pageForPointer(token);
stop = (id *)token;
...
// pop 内部对象直到 stop 边界
page->releaseUntil(stop);
...
// 删除空的 child 链表节点，如果当前页对象超过一半，保留下一个空节点
if (page->lessThanHalfFull()) {
page->child->kill();
}
else if (page->child->child) {
page->child->child->kill();
}
}
pop()的逻辑应该很好理解了，token参数就是边界，下面分别分析步骤：
找到边界对应的 page
static AutoreleasePoolPage *pageForPointer(const void *p) {
return pageForPointer((uintptr_t)p);
}
static AutoreleasePoolPage *pageForPointer(uintptr_t p) {
AutoreleasePoolPage *result;
uintptr_t offset = p % SIZE;
....
result = (AutoreleasePoolPage *)(p - offset);
result->fastcheck();
return result;
}
onst void *p是指针的指针，((uintptr_t)p)才表示POOL_BOUNDARY指针在对应 page 中的地址。
前面分析过内存对齐的处理，那么uintptr_t p的值必然是 SIZE (4096) 的倍数，那么p % SIZE就得到了这个p在 page 中的地址偏移，最后通过p - offset就拿到了 page 的起始地址，这个处理比较秀。
移除被管理对象并发送 release 消息
void releaseUntil(id *stop) {
while (this->next != stop) {
AutoreleasePoolPage *page = hotPage();
// 如果当前 page 空了，指向 parent
while (page->empty()) {
page = page->parent;
setHotPage(page);
}
// 将即将要移除对象对应 page 中的内存置为 SCRIBBLE
page->unprotect();
id obj = *--page->next;
memset((void*)page->next, SCRIBBLE, sizeof(*page->next));
page->protect();
// 调用对象的 release 方法
if (obj != POOL_BOUNDARY) {
objc_release(obj);
}
}
// 把当前 page 设置 hotpage（调用时 this 就是对应期望释放边界的 page）
setHotPage(this);
...
}
清除 child
void kill() {
AutoreleasePoolPage *page = this;
while (page->child) page = page->child;
AutoreleasePoolPage *deathptr;
do {
deathptr = page;
page = page->parent;
if (page) {
page->unprotect();
page->child = nil;
page->protect();
}
delete deathptr;
} while (deathptr != this);
}
这个逻辑一目了然了。
后语
以上就是自动释放池大部分源码的分析了，这部分源码没有涉及汇编并且代码量比较少，所以看起来相对容易。多理解一些内存管理底层有利于理解各种上层特性、定位内存难题，也有助于写出更稳定的代码。并且在这个过程中，不可避免需要接触操作系统和编译原理相关知识，也算是能培养通识性能力
读源码远比记结论重要，遇到某些优秀的代码细节往往令人惊喜，不失为一种乐趣。
参考
[1]http://blog.sunnyxx.com/2014/10/15/behind-autorelease/
[2]https://developer.apple.com/documentation/foundation/nsautoreleasepool#//apple_ref/doc/uid/TP40003623