ARC下，我们使用@autoreleasepool{}来使用一个AutoreleasePool

void main(int argc, char * argv[]) {

       @autoreleasepool {

       }

}

随后编译器将其改写成下面的样子（clang -rewrite-objc main.m）：

报错 main.m:9:9: fatal error: 'UIKit/UIKit.h' file not found，

#import <UIKit/UIKit.h>

尴尬！换个命令 xcrun -sdk iphonesimulator clang -rewrite-objc main.m（指定模拟器/SDK）

如果报错 xcodebuild[3632:229732] [MT] PluginLoading: Required plug-in compatibility UUID E0A62D1F-3C18-4D74-BFE5-A4167D643966 for plug-in at path '~/Library/Application Support/Developer/Shared/Xcode/Plug-ins/CocoaPods.xcplugin' not present in DVTPlugInCompatibilityUUIDs

则Finder 前往这个地址，显示包内存在Info.plist文件的DVTPlugInCompatibilityUUIDs数组中添加一item，值为E0A62D1F-3C18-4D74-BFE5-A4167D643966

~>

int main(int argc, char * argv[]) {

/* @autoreleasepool */   { __AtAutoreleasePool __autoreleasepool;

     }

}

我们写的@autoreleasepool{}变成了 @autoreleasepool  与 {}两部分，第一部分@autorelease被注释，很明显它的作用对于编译器只是一个标示。第二部分{}

__AtAutoreleasePool 是一结构体

struct __AtAutoreleasePool {

     __AtAutoreleasePool() {atautoreleasepoolobj = objc_autoreleasePoolPush();}

     ~__AtAutoreleasePool() {objc_autoreleasePoolPop(atautoreleasepoolobj);}

      void * atautoreleasepoolobj;

};

__AtAutoreleasePool __autoreleasepool;  这一句声明，多少有点C++11 中的trivial的身影（可是看到了结构体中的构造和析构函数，一脸懵逼）

构造函数与类名相同，没有返回值。析构函数与类名相同，前面加上~，没有返回值和参数，对象销毁时自动调用。

未定义构造函数，那么编译器会添加有一个无参的构造函数，而如果定义了构造函数，不会默认生成，如果你还想允许无参构造，就必须显式的声明一个

尽管有点诡异，但是构造函数和析构函数还在那摆着呢。以上代码等价于

void main(int argc, const char * argv[]) {

{

      void * autoreleasepoolobj = objc_autoreleasePoolPush();

      objc_autoreleasePoolPop(autoreleasepoolobj);

}

结构体会在初始化时调用 objc_autoreleasePoolPush() 方法，会在析构时(出作用域)调用 objc_autoreleasePoolPop 方法

@autoreleasepool 只是帮助我们少写了这两行代码而已，让代码看起来更美观。我们下面就要依据这两个方法，展开

void *objc_autoreleasePoolPush(void) {

      return AutoreleasePoolPage::push();

}

void objc_autoreleasePoolPop(void *ctxt) {

      AutoreleasePoolPage::pop(ctxt);

}

AutoreleasePoolPage 的静态方法push 和 pop,两个函数都是对AutoreleasePoolPage的简单封装

AutoreleasePoolPage is who?

AutoreleasePoolPage是一个C++实现的类

class AutoreleasePoolPage {

      magic_t const magic;

      id *next;

      pthread_t const thread;

      AutoreleasePoolPage * const parent;

      AutoreleasePoolPage *child;

      uint32_t const depth;

      uint32_t hiwat;

};

1 magic 用于对当前 AutoreleasePoolPage 完整性的校验

2 AutoreleasePool是按线程一一对应的（结构中的thread指针指向当前线程）

3 AutoreleasePool（自动释放池）并没有单独的结构，而是由若干个AutoreleasePoolPage组合。每一个 AutoreleasePoolPage 的大小都是4096 字节， 前56 bit 用于存储 AutoreleasePoolPage 的成员变量，剩下的用来存储加入到自动释放池中的对象（autorelease对象的地址）

4 上面的next指针作为游标，指向栈顶最新add进来的autorelease对象的下一个位置

next 指向了下一个为空的内存地址，如果 next 指向的地址加入一个 object，它就会如下图所示移动到下一个为空的内存地址中

5 一个AutoreleasePoolPage的空间被占满时，会新建一个AutoreleasePoolPage对象，连接链表，后来的autorelease对象在新的page加入

6 AutoreleasePoolPage 是双向链表的形式连接起来的（parent 和 child 用来构造双向链表的指针）

7 begin() 和 end() 这两个类的实例方法获取一个AutoreleasePoolPage的存储autorelease对象地址的区域边界

到了这里，你可能想要知道 POOL_SENTINEL 到底是什么，还有它为什么在栈中？

#define POOL_SENTINEL nil

POOL_SENTINEL 只是 nil 的别名，是一个哨兵对象。

static inline void *push() {

       return autoreleaseFast(POOL_SENTINEL);

}

static inline id *autoreleaseFast(id obj)

{

     AutoreleasePoolPage *page = hotPage();

     //有 hotPage 并且 hotPage 不满

     if (page && !page->full()) {  

          //调用 page->add(obj) 方法将对象添加至 AutoreleasePoolPage 的栈中

          return page->add(obj);

      } else if (page) {//有 hotPage 并且hotPage 已满

             return autoreleaseFullPage(obj, page);

      } else {

         //无 hotPage

              return autoreleaseNoPage(obj);   

      }

}

1 objc_autoreleasePoolPush -> AutoreleasePoolPage::push --> autoreleaseFast(POOL_SENTINEL)

因此，调用objc_autoreleasePoolPush，最终调用autoreleaseFast 方法，并传入哨兵对象 POOL_SENTINEL

2 该函数分三种情况选择不同的代码执行（hotPage 可以理解为当前正在使用的 AutoreleasePoolPage）

将哨兵对象添加到hotPage中（page->add 添加对象），对函数整理简化

id *add(id obj) {

     id *ret = next;

     *next = obj;

      next++;

      return ret;

}

这个函数其实就是一个压栈的操作，将对象加入 AutoreleasePoolPage 然后移动栈顶的指针。

autoreleaseFast(POOL_SENTINEL)，函数返回的是哨兵对象的地址

然后，顺便看下autoreleaseFullPage()与autoreleaseNoPage()函数（page->child指向下一页page）

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

}

会从传入的 page 开始遍历整个双向链表，直到查找到一个未满的 AutoreleasePoolPage，否则使用构造器传入 parent 创建一个新的 AutoreleasePoolPage。得到一个可用的 AutoreleasePoolPage 之后，会将该页面标记成 hotPage，然后调动上面分析过的 page->add 方法添加对象

如果不存在 hotPage，就会调用 autoreleaseNoPage 方法初始化一个 AutoreleasePoolPage,从头开始构建双向链表，也就是说，新的 AutoreleasePoolPage 是没有 parent 指针的

static id *autoreleaseNoPage(id obj) {

      AutoreleasePoolPage *page = new AutoreleasePoolPage(nil);

      setHotPage(page);

      if (obj != POOL_SENTINEL) {

//可见成员变量之上必然是哨兵对象，无论传入与否。来确保在 pop 调用的时候，不会出现异常

             page->add(POOL_SENTINEL);

       }

       return page->add(obj);

}

综上，autoreleaseFast()将哨兵对象添加到hotpage中，并返回哨兵对象的地址

3  objc_autoreleasePoolPush之后，autorelease对象必然执行类似操作进栈，纷纷添加到page中，直到objc_autoreleasePoolPop()（参数对应push返回值，哨兵对象的地址）

static inline void pop(void *token) {

    //获取哨兵对象所在page（首地址）

    AutoreleasePoolPage *page = pageForPointer(token);

    id *stop = (id *)token;

    //释放本次push进的对象

     page->releaseUntil(stop);

    //根据当前页的不同状态 kill 掉不同 child 的页面

    if (page->child) {

        if (page->lessThanHalfFull()) {

               page->child->kill();

        } else if (page->child->child) {   

               page->child->child->kill();

         }

     }

}

pageForPointer 方法主要是通过内存地址的操作，获取当前指针所在页的首地址

static AutoreleasePoolPage *pageForPointer(const void *p) {

     return pageForPointer((uintptr_t)p);

}

static AutoreleasePoolPage *pageForPointer(uintptr_t p) {

     AutoreleasePoolPage *result;

      uintptr_t offset = p % SIZE;

      assert(offset >= sizeof(AutoreleasePoolPage));

      result = (AutoreleasePoolPage *)(p - offset);

      result->fastcheck();  

      return result;

}

将指针地址与页面的大小（如4096）取模，得到指针在page中的偏移量（因为所有的 AutoreleasePoolPage 在内存中都是对齐的）减去偏移量得到page的首地址，最后调用fastCheck() 用来检查此地址是不是一个 AutoreleasePoolPage（通过检查成员magic）

回到 pop函数，然后 page->releaseUntil(stop); 哨兵对象所在页page调用releaseUntil，参数是哨兵对象的地址

void releaseUntil(id *stop) {

      while (this->next != stop) {

               AutoreleasePoolPage *page = hotPage(); 

                while (page->empty()) {

                          page = page->parent;   

                           setHotPage(page);

                 }

                   page->unprotect();

                    id obj = *--page->next;  

                    memset((void*)page->next, SCRIBBLE, sizeof(*page->next));

                    page->protect();

                   if (obj != POOL_SENTINEL) {

                            objc_release(obj);  }

       }

       setHotPage(this);

}

这里，需要明白一点：

可能此次push进page的对象（指针）比较多，哨兵对象所在的page已不是hotpage

但是，由autoreleaseFullPage()可以看出，hotpage必然是哨兵对象所在的page的子节点（子子节点~）

找到当前hotpage，如果已空，通过parent指针遍历双向链表，找到不空的page作为hotpage（这个就是对应上面的情况，将hotpage清空，然后找到父节点继续，直到来到哨兵对象地址）

通过page的next指针， memset将内存的内容设置成 SCRIBBLE，然后使用 objc_release 释放对象，next指针必然前移。继续循环释放对象

每次进栈，add位置依据next指针指向，之后next指向后移。进栈依据next指针，出栈也是依据next指针。出栈之后，之后next指向前移。push可能用到多页page，释放必然也可能释放多页page，因此push进栈涉及到hotpage的变换，pop出栈也涉及到hotpage的切换。

这是一个不断出栈的过程，只要哨兵对象所在页page的next指针不指向此哨兵对象，循环继续

以上，就是源码分析。我们应该知道：

1 如果存在多个自动释放池，那么它们在page之间的界限就是哨兵对象

2 自动释放池的嵌套

@autoreleasepool {//pool 1

      obj1 = xxx autorelease;

       @autoreleasepool {//pool 2

                __autoreleasing obj2 = xxx;

                       @autoreleasepool {//pool 3

                                   obj3 = alloc;

                        }

                }

     }

它们在page中的位置，如下（假设同一个page）

next指针指向

pool 3哨兵对象 nil

obj2地址

pool 2哨兵对象 nil

obj1地址

pool 1哨兵对象 nil

加入释放池，也是依据代码顺序，加入到对应的哨兵对象之后。释放池废弃时，也是先依据代码顺序，先释放最内测的释放池。当然这仅仅是以一个page为例

我们之前说过，RunLoop每次循环会创建自动释放池，这个自动释放必然是很外侧的自动释放池，而我们手动创建的相对于该自动释放池是相对内侧的释放池，该自动释放池释放时，内侧的自动释放池s必然一同释放（循环）