內存管理一直是學習 Objective-C 的重點和難點之一，盡管現在已經是 ARC 時代了，但是了解 Objective-C 的內存管理機制仍然是十分必要的。
Autorelease機制是iOS開發者管理對象內存的好伙伴，MRC中，調用[obj autorelease] 來延遲內存的釋放是一件簡單自然的事，ARC下，我們甚至可以完全不知道Autorelease就能管理好內存。而在這背后，objc和編譯器都幫我們做了哪些事呢，它們是如何協作來正確管理內存的呢？刨根問底，一起來探究下黑幕背后的Autorelease機制。

Autorelease對象什么時候釋放？

很多答案都是“當前作用域大括號結束時釋放”，顯然木有正確理解Autorelease機制.
在沒有手加Autorelease Pool的情況下，Autorelease對象是在當前的runloop迭代結束時釋放的，而它能夠釋放的原因是系統在每個runloop迭代中都加入了自動釋放池Push和Pop.

從 main 函數開始

main 函數可以說是在整個 iOS 開發中非常不起眼的一個函數，它很好地隱藏在 Supporting Files 文件夾中，卻是整個 iOS 應用的入口。

main.m 文件中的代碼：

int main(int argc, char * argv[]) {
    @autoreleasepool {
        return UIApplicationMain(argc, argv, nil, NSStringFromClass([AppDelegate class]));
    }
}

在這個 @autoreleasepool block 中只包含了一行代碼，這行代碼將所有的事件、消息全部交給了 UIApplication 來處理，但是這不是本文關注的重點。
需要注意的是：整個 iOS 的應用都是包含在一個自動釋放池 block 中的。

Autorelease原理

@autoreleasepool 到底是什么？我們在命令行中使用 clang -rewrite-objc main.m讓編譯器重新改寫這個文件得到cpp文件，在cpp文件代碼中我們找到main函數代碼：

int main(int argc, const char * argv[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 
    }
    return 0;
}

為了弄清楚這行含義，我們找到__AtAutoreleasePool結構體：

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

這個結構體會在初始化時調用 objc_autoreleasePoolPush() 方法，會在析構時調用 objc_autoreleasePoolPop 方法。
這表明，我們的 main 函數在實際工作時其實是這樣的：

int main(int argc, const char * argv[]) {
    {
        void * atautoreleasepoolobj = objc_autoreleasePoolPush();
        objc_autoreleasePoolPop(atautoreleasepoolobj);
    }
    return 0;
}

@autoreleasepool 只是幫助我們少寫了這兩行代碼而已，讓代碼看起來更美觀，然后要根據上述兩個方法來分析自動釋放池的實現。
來看一下objc_autoreleasePoolPush 和 objc_autoreleasePoolPop 的實現：

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

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

上面的方法看上去是對 AutoreleasePoolPage 對應靜態方法 push 和 pop 的封裝。

AutoreleasePoolPage 的結構

AutoreleasePoolPage 是一個 C++ 中的類，它在 NSObject.mm 中的定義是這樣的：

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

• magic 用于對當前 AutoreleasePoolPage 完整性的校驗
• thread 保存了當前頁所在的線程
  每一個自動釋放池都是由一系列的 AutoreleasePoolPage 組成的，并且每一個 AutoreleasePoolPage 的大小都是 4096 字節（16 進制 0x1000）

#define I386_PGBYTES 4096
#define PAGE_SIZE I386_PGBYTES

雙向鏈表

自動釋放池中的 AutoreleasePoolPage 是以雙向鏈表的形式連接起來的：

自動釋放池中的棧

如果我們的一個 AutoreleasePoolPage 被初始化在內存的 0x100816000 ~ 0x100817000 中，它在內存中的結構如下：

其中有 56 bit 用于存儲AutoreleasePoolPage 的成員變量，剩下的 0x100816038 ~ 0x100817000 都是用來存儲加入到自動釋放池中的對象。
begin() 和 end() 這兩個類的實例方法幫助我們快速獲取 0x100816038 ~ 0x100817000 這一范圍的邊界地址。

next 指向了下一個為空的內存地址，如果 next指向的地址加入一個 object，它就會如下圖所示移動到下一個為空的內存地址中：

• AutoreleasePool并沒有單獨的結構，而是由若干個AutoreleasePoolPage以雙向鏈表的形式組合而成（分別對應結構中的parent指針和child指針）

• AutoreleasePool是按線程一一對應的（結構中的thread指針指向當前線程）
• AutoreleasePoolPage每個對象會開辟4096字節內存（也就是虛擬內存一頁的大小），除了上面的實例變量所占空間，剩下的空間全部用來儲存autorelease對象的地址
• 上面的id *next指針作為游標指向棧頂最新add進來的autorelease對象的下一個位置
• 一個AutoreleasePoolPage的空間被占滿時，會新建一個AutoreleasePoolPage對象，連接鏈表，后來的autorelease對象在新的page加入

POOL_SENTINEL（哨兵對象）

到了這里，你可能想要知道 POOL_SENTINEL到底是什么，還有它為什么在棧中。
首先回答第一個問題： POOL_SENTINEL 只是 nil 的別名。

#define POOL_SENTINEL nil

在每個自動釋放池初始化調用objc_autoreleasePoolPush的時候，都會把一個POOL_SENTINEL push 到自動釋放池的棧頂，并且返回這個 POOL_SENTINEL 哨兵對象。

int main(int argc, const char * argv[]) {
    {
        void * atautoreleasepoolobj = objc_autoreleasePoolPush();
        objc_autoreleasePoolPop(atautoreleasepoolobj);
    }
    return 0;
}

上面的 atautoreleasepoolobj就是一個POOL_SENTINEL。
而當方法objc_autoreleasePoolPop 調用時，就會向自動釋放池中的對象發送release消息，直到第一個 POOL_SENTINEL：

objc_autoreleasePoolPush的返回值正是這個哨兵對象的地址，被objc_autoreleasePoolPop(哨兵對象)作為入參，于是：

• 根據傳入的哨兵對象地址找到哨兵對象所處的page
• 在當前page中，將晚于哨兵對象插入的所有autorelease對象都發送一次- release消息，并向回移動next指針到正確位置
• 補充2：從最新加入的對象一直向前清理，可以向前跨越若干個page，直到哨兵所在的page

objc_autoreleasePoolPush 方法

了解了 POOL_SENTINEL，我們來重新回顧一下 objc_autoreleasePoolPush 方法：

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

它調用AutoreleasePoolPage的類方法push，也非常簡單：

static inline void *push() {
   return autoreleaseFast(POOL_SENTINEL);
}

在這里會進入一個比較關鍵的方法autoreleaseFast，并傳入哨兵對象 POOL_SENTINEL：

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->add(obj) 方法將對象添加至 AutoreleasePoolPage 的棧中
• 有 hotPage 并且當前 page 已滿
  》調用 autoreleaseFullPage 初始化一個新的頁
  》調用 page->add(obj) 方法將對象添加至 AutoreleasePoolPage 的棧中
• 無 hotPage
  》調用 autoreleaseNoPage 創建一個 hotPage
  》調用 page->add(obj) 方法將對象添加至 AutoreleasePoolPage 的棧中
  最后的都會調用 page->add(obj) 將對象添加到自動釋放池中。
  hotPage 可以理解為當前正在使用的 AutoreleasePoolPage。

page->add 添加對象

id *add(id obj) 將對象添加到自動釋放池頁中：

id *add(id obj) {
    id *ret = next;
    *next = obj;
    next++;
    return ret;
}

這個方法其實就是一個壓棧的操作，將對象加入 AutoreleasePoolPage 然后移動棧頂的指針。

autoreleaseFullPage（當前 hotPage 已滿）

autoreleaseFullPage 會在當前的 hotPage 已滿的時候調用：

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 開始遍歷整個雙向鏈表，直到：
1、查找到一個未滿的AutoreleasePoolPage
2、使用構造器傳入 parent 創建一個新的 AutoreleasePoolPage

在查找到一個可以使用的 AutoreleasePoolPage 之后，會將該頁面標記成 hotPage，然后調動上面分析過的page->add 方法添加對象。

autoreleaseNoPage（沒有 hotPage)

如果當前內存中不存在 hotPage，就會調用 autoreleaseNoPage 方法初始化一個 AutoreleasePoolPage：

static id *autoreleaseNoPage(id obj) {
    AutoreleasePoolPage *page = new AutoreleasePoolPage(nil);
    setHotPage(page);

    if (obj != POOL_SENTINEL) {
        page->add(POOL_SENTINEL);
    }

    return page->add(obj);
}

既然當前內存中不存在AutoreleasePoolPage，就要從頭開始構建這個自動釋放池的雙向鏈表，也就是說，新的AutoreleasePoolPage 是沒有 parent 指針的。

初始化之后，將當前頁標記為 hotPage，然后會先向這個 page 中添加一個 POOL_SENTINEL 對象，來確保在pop調用的時候，不會出現異常。
最后，將 obj 添加到自動釋放池中。

objc_autoreleasePoolPop 方法

同樣，回顧一下上面提到的 objc_autoreleasePoolPop 方法：

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

看起來傳入任何一個指針都是可以的，但是在整個工程并沒有發現傳入其他對象的例子。不過在這個方法中傳入其它的指針也是可行的，會將自動釋放池釋放到相應的位置。

我們一般都會在這個方法中傳入一個哨兵對象 POOL_SENTINEL，如下圖一樣釋放對象：

對 objc_autoreleasePoolPop 行為的測試

在繼續分析這個方法之前做一個小測試，在 objc_autoreleasePoolPop 傳入非哨兵對象，測試一下這個方法的行為。
下面是 main.m 文件中的源代碼：

#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
    @autoreleasepool {

        NSString *s = @"Draveness";
        [s stringByAppendingString:@"-Suffix"];
    }
    return 0;
}

在代碼的這一行打一個斷點，因為這里會調用 autorelease 方法，將字符串加入自動釋放池：

當代碼運行到這里時，通過 lldb 打印出當前 hotPage 中的棧內容：

• 通過 static 方法獲取當前 hotPage
• 打印 AutoreleasePoolPage 中的內容
• 打印當前 next 指針指向的內容，以及之前的內容，-2時已經到了 begin() 位置
• 使用 print()和 printAll()打印自動釋放池中內容

然后將字符串 @"Draveness-Suffix" 的指針傳入 pop 方法，測試 pop 方法能否傳入非哨兵參數。

page->releaseUntil(stop);

if (page->child) {
    if (page->lessThanHalfFull()) {
        page->child->kill();
    } else if (page->child->child) {
        page->child->child->kill();
    }
}

}
`
在這個方法中刪除了大量無關的代碼，以及對格式進行了調整。
該靜態方法總共做了三件事情：

• 使用 pageForPointer獲取當前 token所在的 AutoreleasePoolPage

• 調用 releaseUntil 方法釋放棧中的對象，直到 stop

• 調用 child 的 kill 方法

我到現在也不是很清楚為什么要根據當前頁的不同狀態 kill 掉不同 child 的頁面。

if (page->lessThanHalfFull()) {
    page->child->kill();
} else if (page->child->child) {
    page->child->child->kill();
}

pageForPointer 獲取 AutoreleasePoolPage

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 取模，得到當前指針的偏移量，因為所有的 AutoreleasePoolPage 在內存中都是對齊的：

p = 0x100816048
p % SIZE = 0x48
result = 0x100816000

而最后調用的方法fastCheck()用來檢查當前的result 是不是一個 AutoreleasePoolPage。

通過檢查 magic_t 結構體中的某個成員是否為 0xA1A1A1A1。

releaseUntil 釋放對象

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

它的實現還是很容易的，用一個 while 循環持續釋放AutoreleasePoolPage 中的內容，直到 next指向了 stop。

使用 memset 將內存的內容設置成 SCRIBBLE，然后使用 objc_release釋放對象。

kill() 方法

到這里，沒有分析的方法就只剩下 kill 了，而它會將當前頁面以及子頁面全部刪除：

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

autorelease 方法

我們已經對自動釋放池生命周期有一個比較好的了解，最后需要了解的話題就是autorelease方法的實現，先來看一下方法的調用棧：

- [NSObject autorelease]
└── id objc_object::rootAutorelease()
    └── id objc_object::rootAutorelease2()
        └── static id AutoreleasePoolPage::autorelease(id obj)
            └── static id AutoreleasePoolPage::autoreleaseFast(id obj)
                ├── id *add(id obj)
                ├── static id *autoreleaseFullPage(id obj, AutoreleasePoolPage *page)
                │   ├── AutoreleasePoolPage(AutoreleasePoolPage *newParent)
                │   └── id *add(id obj)
                └── static id *autoreleaseNoPage(id obj)
                    ├── AutoreleasePoolPage(AutoreleasePoolPage *newParent)
                    └── id *add(id obj)

在autorelease方法的調用棧中，最終都會調用上面提到的 autoreleaseFast方法，將當前對象加到AutoreleasePoolPage 中。

這一小節中這些方法的實現都非常容易，只是進行了一些參數上的檢查，最終還要調用autoreleaseFast方法：

inline id objc_object::rootAutorelease() {
    if (isTaggedPointer()) return (id)this;
    if (prepareOptimizedReturn(ReturnAtPlus1)) return (id)this;

    return rootAutorelease2();
}

__attribute__((noinline,used)) id objc_object::rootAutorelease2() {
    return AutoreleasePoolPage::autorelease((id)this);
}

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

由于在上面已經分析過autoreleaseFast方法的實現，這里就不會多說了。

Autorelease返回值的快速釋放機制

值得一提的是，ARC下，runtime有一套對autorelease返回值的優化策略。
比如一個工廠方法：

+ (instancetype)createSark {
    return [self new];
}
// caller
Sark *sark = [Sark createSark];

秉著誰創建誰釋放的原則，返回值需要是一個autorelease對象才能配合調用方正確管理內存，于是乎編譯器改寫成了形如下面的代碼：

+ (instancetype)createSark {
    id tmp = [self new];
    return objc_autoreleaseReturnValue(tmp); // 代替我們調用autorelease
}
// caller
id tmp = objc_retainAutoreleasedReturnValue([Sark createSark]) // 代替我們調用retain
Sark *sark = tmp;
objc_storeStrong(&sark, nil); // 相當于代替我們調用了release

一切看上去都很好，不過既然編譯器知道了這么多信息，干嘛還要勞煩autorelease這個開銷不小的機制呢？于是乎，runtime使用了一些黑魔法將這個問題解決了。

小結

整個自動釋放池 AutoreleasePool 的實現以及``autorelease `方法都已經分析完了，我們再來回顧一下文章中的一些內容：

• 自動釋放池是由 AutoreleasePoolPage 以雙向鏈表的方式實現的
• 當對象調用 autorelease 方法時，會將對象加入 AutoreleasePoolPage 的棧中
• 調用 AutoreleasePoolPage::pop 方法會向棧中的對象發送 release 消息

參考資料

http://www.cocoachina.com/ios/20160702/16569.html
http://blog.sunnyxx.com/2014/10/15/behind-autorelease/