Autorelease 機制是 iOS 開發者管理物件記憶體的好夥伴，MRC中，呼叫 [obj autorelease] 來延遲記憶體的釋放是一件簡單自然的事，ARC下，我們甚至可以完全不知道 Autorelease 就能管理好記憶體。而在這背後，objc 和編譯器都幫我們做了哪些事呢，它們是如何協作來正確管理記憶體的呢？刨根問底，一起來探究下黑幕背後的 Autorelease 機制。
1.Autoreleased 物件何時被釋放
autorelease 本質上就是延遲呼叫 release，那 autoreleased 物件究竟會在什麼時候釋放呢？以下我們來做一個實驗。
特別說明：在蘋果一些新的硬體裝置上，本實驗的結果已經不再成立，詳細情況如下：
-
iPad 2
-
iPad Air -
iPad Air 2 -
iPad Pro -
iPad Retina
-
iPhone 4s
-
iPhone 5
-
iPhone 5s -
iPhone 6 -
iPhone 6 Plus -
iPhone 6s -
iPhone 6s Plus__weak NSString *string_weak_ = nil; - (void)viewDidLoad { [super viewDidLoad]; // 場景 1 NSString *string = [NSString stringWithFormat:@"leichunfeng"]; string_weak_ = string; // 場景 2 // @autoreleasepool { // NSString *string = [NSString stringWithFormat:@"leichunfeng"]; // string_weak_ = string; // } // 場景 3 // NSString *string = nil; // @autoreleasepool { // string = [NSString stringWithFormat:@"leichunfeng"]; // string_weak_ = string; // } NSLog(@"string: %@", string_weak_); } - (void)viewWillAppear:(BOOL)animated { [super viewWillAppear:animated]; NSLog(@"string: %@", string_weak_); } - (void)viewDidAppear:(BOOL)animated { [super viewDidAppear:animated]; NSLog(@"string: %@", string_weak_); } 複製程式碼讓我們一起來看看 console 輸出：
// 場景 1 2015-05-30 10:32:20.837 AutoreleasePool[33876:1448343] string: leichunfeng 2015-05-30 10:32:20.838 AutoreleasePool[33876:1448343] string: leichunfeng 2015-05-30 10:32:20.845 AutoreleasePool[33876:1448343] string: (null) // 場景 2 2015-05-30 10:32:50.548 AutoreleasePool[33915:1448912] string: (null) 2015-05-30 10:32:50.549 AutoreleasePool[33915:1448912] string: (null) 2015-05-30 10:32:50.555 AutoreleasePool[33915:1448912] string: (null) // 場景 3 2015-05-30 10:33:07.075 AutoreleasePool[33984:1449418] string: leichunfeng 2015-05-30 10:33:07.075 AutoreleasePool[33984:1449418] string: (null) 2015-05-30 10:33:07.094 AutoreleasePool[33984:1449418] string: (null) 複製程式碼
分析
3 種場景下，我們都通過 [NSString stringWithFormat:@"leichunfeng"] 建立了一個 autoreleased 物件，這是我們實驗的前提。並且，為了能夠在 viewWillAppear 和 viewDidAppear 中繼續訪問這個物件，我們使用了一個全域性的 __weak 變數 string_weak_ 來指向它。因為 __weak 變數有一個特性就是它不會影響所指向物件的生命週期，這裡我們正是利用了這個特性。
場景 1
當使用 [NSString stringWithFormat:@"leichunfeng"] 建立一個物件時，這個物件的引用計數為 1，並且這個物件被系統自動新增到了當前的 autoreleasepool 中。當使用區域性變數 string 指向這個物件時，這個物件的引用計數 +1 ，變成了 2。因為在 ARC 下 NSString *string 本質上就是 __strong NSString *string。所以在 viewDidLoad 方法返回前，這個物件是一直存在的，且引用計數為 2。而當 viewDidLoad 方法返回時，區域性變數 string 被回收，指向了 nil。因此，其所指向物件的引用計數 -1，變成了 1。
而在 viewWillAppear 方法中，我們仍然可以列印出這個物件的值，說明這個物件並沒有被釋放。不是一直都說當函式返回的時候，函式內部產生的物件就會被釋放的嗎？前面我們提到了，這個物件是一個 autoreleased 物件，autoreleased 物件是被新增到了當前最近的 autoreleasepool 中了，只有當這個 autoreleasepool 自身 drain 的時候，autoreleasepool 中的 autoreleased 物件才會被 release。
另外，我們注意到當在 viewDidAppear 中再列印這個物件的時候，物件的值變成了 nil ，說明此時物件已經被釋放了。因此，我們可以大膽地猜測一下，這個物件一定是在 viewWillAppear 和 viewDidAppear 方法之間的某個時候被釋放了，並且是由於它所在的 autoreleasepool 被 drain 的時候釋放的。
場景 2
同理，當通過 [NSString stringWithFormat:@"leichunfeng"] 建立一個物件時，這個物件的引用計數為 1。而當使用區域性變數 string 指向這個物件時，這個物件的引用計數 +1，變成了 2。而出了當前作用域時，區域性變數 string 變成了 nil ，所以其所指向物件的引用計數變成 1。另外，我們知道當出了 @autoreleasepool {} 的作用域時，當前 autoreleasepool 被 drain，其中的 autoreleased 物件被 release。所以這個物件的引用計數變成了 0，物件最終被釋放。
場景 3
同理，當出了 @autoreleasepool {} 的作用域時，其中的 autoreleased 物件被 release，物件的引用計數變成 1。當出了區域性變數 string 的作用域，即 viewDidLoad 方法返回時，string 指向了 nil，其所指向物件的引用計數變成 0，物件最終被釋放。
總結
理解在這 3 種場景下，autoreleased 物件什麼時候釋放對我們理解 Objective-C 的記憶體管理機制非常有幫助。其中，場景 1 出現得最多，就是不需要我們手動新增 @autoreleasepool {} 的情況，直接使用系統維護的 autoreleasepool ；場景 2 就是需要我們手動新增 @autoreleasepool {} 的情況，手動干預 autoreleased 物件的釋放時機；場景 3 是為了區別場景 2 而引入的，在這種場景下並不能達到出了 @autoreleasepool {} 的作用域時 autoreleased 物件被釋放的目的。
注意：不要混淆 autoreleasepool 與 @autoreleasepool {}
2.AutoreleasePool 與 RunLoop
首先我們明確什麼物件會自動加入 autoreleasepool ：
- MRC 下需要物件呼叫 autorelease 才會入池, ARC 下可以通過 __autoreleasing 修飾符，否則的話看方法名，通過呼叫 alloc/new/copy/mutablecopy 以外的方法取得的物件，編譯器幫我們自動加入 autoreleasepool (使用 alloc/new/copy/mutablecopy 方法進行初始化時，由系統管理物件，在適當的位置 release，不加入 autoreleasepool )。
- 使用 array 會自動將返回物件註冊到 autoreleasepool。
- __weak 修飾的物件，為了保證在引用時不被廢棄，會註冊到 autoreleasepool 中。
- id 的指標或物件的指標，在沒有顯式指定時會被註冊到 autoreleasepool 中。
前面一節我們講到，autoreleased 物件會被加到最近的 autoreleasepool 中，只有當這個 autoreleasepool 自身 drain 的時候，autoreleasepool 中的 autoreleased 物件才會被 release (retainCount = 0 時物件釋放)。
那麼 autoreleasepool 是在什麼時候釋放的呢。個人覺得有以下兩種情況：
-
MRC 下顯式的呼叫 drain 方法。對於獲取不到的 NSAutoreleasePool 物件無法操作，不是我們討論的重點。
-
在 runloop 開始時，都會隱式建立一個 autoreleasepool，並會在 runloop 結束時把前面建立的 autoreleasepool drain。
程式執行 -> 開啟事件迴圈 -> 發生觸控事件 -> 建立自動釋放池 -> 處理觸控事件 -> 事件物件加入自動釋放池 -> 一次事件迴圈結束，銷燬自動釋放池
至於 runloop 何時結束就無法確定了。
上面場景一中，由於呼叫的非 alloc/new/copy/mutablecopy 方法取得物件，這個物件就自動被系統新增到了由主執行緒的 NSRunLoop 物件建立的 autoreleasepool 中，並在這個 autoreleasepool 被 drain 時得到釋放。然而 runloop 何時結束無法確定，我們也不能顯式的呼叫 drain 方法，那有沒有好的解決辦法呢？幸運的是可以。我們可以使用 NSAutoreleasepool 或 @autoreleasepool {}將物件加入到我們建立的 autorelasepool 中，手動干預釋放 (如場景二)。
之所以可以這麼做肯定和它的實現原理有關，下面我們具體討論它的結構，相信大家看完肯定能有自己的結論。
3.AutoreleasePool 的實現
3.1 從 main 函式開始
main 函式可以說是在整個 iOS 開發中非常不起眼的一個函式，但卻是整個 iOS 應用的入口。
main.m 檔案中的內容是這樣的：
int main(int argc, char * argv[]) {
@autoreleasepool {
return UIApplicationMain(argc, argv, nil, NSStringFromClass([AppDelegate class]));
}
}
複製程式碼在這個 @autoreleasepool block 中只包含了一行程式碼，這行程式碼將所有的事件、訊息全部交給了 UIApplication 來處理，但是這不是本文關注的重點。
需要注意的是：整個 iOS 的應用都是包含在一個自動釋放池 block 中的。
3.2 @autoreleasepool
@autoreleasepool 到底是什麼？我們在命令列中使用使用以下命令讓編譯器重新改寫這個檔案：
clang -x objective-c -rewrite-objc -isysroot /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator.sdk main.m
複製程式碼在生成了一大堆警告之後，當前目錄下多了一個 main.cpp 檔案。在檔案的最後，我們可以看到如下程式碼：
int main(int argc, char * argv[]) {
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
return UIApplicationMain(argc, argv, __null, NSStringFromClass(((Class (*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("AppDelegate"), sel_registerName("class"))));
}
}
複製程式碼在這個檔案中，有一個非常奇怪的 __AtAutoreleasePool 的結構體，前面的註釋寫到 /* @autoreleasepopl */。也就是說 @autoreleasepool {} 被轉換為一個 __AtAutoreleasePool 結構體：
{
__AtAutoreleasePool __autoreleasepool;
}
複製程式碼想要弄清楚這行程式碼的意義，我們要在 main.cpp 中查詢名為 __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();
// do whatever you want
objc_autoreleasePoolPop(atautoreleasepoolobj);
}
return 0;
}
複製程式碼@autoreleasepool 只是幫助我們少寫了這兩行程式碼而已，讓程式碼看起來更美觀。
4.AutoreleasePool 原始碼解析
這一節開始分析方法 objc_autoreleasePoolPush 和 objc_autoreleasePoolPop 的實現：
void *objc_autoreleasePoolPush(void) {
return AutoreleasePoolPage::push();
}
void objc_autoreleasePoolPop(void *ctxt) {
AutoreleasePoolPage::pop(ctxt);
}
複製程式碼上面的方法看上去是對 AutoreleasePoolPage 對應靜態方法 push 和 pop 的封裝。
這一小節會按照下面的順序逐步解析程式碼中的內容：
- AutoreleasePoolPage 的結構
- objc_autoreleasePoolPush 方法
- objc_autoreleasePoolPop 方法
4.1 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 是以雙向連結串列的形式連線起來的：
parent 和 child 就是用來構造雙向連結串列的指標。
自動釋放池中的棧
如果我們的一個 AutoreleasePoolPage 被初始化在記憶體的 0x100816000 ~ 0x100817000 中，它在記憶體中的結構如下：
其中有 56 bit 用於儲存 AutoreleasePoolPage 的成員變數，剩下的 0x100816038 ~ 0x100817000 都是用來儲存加入到自動釋放池中的物件。
begin() 和 end() 這兩個類的例項方法幫助我們快速獲取 0x100816038 ~ 0x100817000 這一範圍的邊界地址。
next 指向了下一個為空的記憶體地址，如果 next 指向的地址加入一個 object，它就會如下圖所示移動到下一個為空的記憶體地址中：
關於 hiwat 和 depth 在文章中並不會進行介紹，因為它們並不影響整個自動釋放池的實現，也不在關鍵方法的呼叫棧中。
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();
// do whatever you want
objc_autoreleasePoolPop(atautoreleasepoolobj);
}
return 0;
}
複製程式碼上面的 atautoreleasepoolobj 就是一個 POOL_SENTINEL。
而當方法 objc_autoreleasePoolPop 呼叫時，就會向自動釋放池中的物件傳送 release 訊息，直到第一個 POOL_SENTINEL：
4.2 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 開始遍歷整個雙向連結串列，直到：
- 查詢到一個未滿的 AutoreleasePoolPage
- 使用構造器傳入 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 新增到自動釋放池中。
4.3 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 方法能否傳入非哨兵引數。
再次列印當前 AutoreleasePoolPage 的內容時，字串已經不存在了，這說明向 pop 方法傳入非哨兵引數是可行的，只是我們一般不會傳入非哨兵物件。
讓我們重新回到對 objc_autoreleasePoolPop 方法的分析，也就是 AutoreleasePoolPage::pop 方法的呼叫：
static inline void pop(void *token) {
AutoreleasePoolPage *page = pageForPointer(token);
id *stop = (id *)token;
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 方法
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);
}
複製程式碼4.4 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 方法的實現，這裡就不會多說了。
4.5 小結
整個自動釋放池 autoreleasepool 的實現以及 autorelease 方法都已經分析完了，我們再來回顧一下文章中的一些內容：
- 自動釋放池是由 AutoreleasePoolPage 以雙向連結串列的方式實現的。
- 當物件呼叫 autorelease 方法時，會將物件加入 AutoreleasePoolPage 的棧中。
- 呼叫 AutoreleasePoolPage::pop 方法會向棧中的物件傳送 release 訊息。
5.拾遺
5.1 NSAutoreleasePool
NSAutoreleasePool 是 Cocoa 用來支援引用計數記憶體管理機制的類，當一個 autorelease pool 被 drain 的時候會對 pool 裡的物件傳送一條 release 的訊息。(不能在 ARC 下使用)
使用方法如下：
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
NSArray *array = [[[NSArray alloc] init] autorelease];
[pool drain];
複製程式碼5.2 AutoreleasePool 與執行緒
每一個執行緒 (包括主執行緒) 都有一個 autoreleasepool 棧。當一個新的池子被建立的時候，push 進棧，當池子被釋放記憶體時，pop 出棧。物件呼叫 autorelease 方法進入棧頂的池子中。當執行緒結束的時候，它會自動地銷燬掉所有跟它有關聯的池子。
5.3 容器的 block 版本的列舉器
使用容器的 block 版本的列舉器時，內部會自動新增一個 autoreleasepool：
[array enumerateObjectsUsingBlock:^(id obj, NSUInteger idx, BOOL *stop) {
// 這裡被一個區域性@autoreleasepool包圍著
}];
複製程式碼當然，在普通 for 迴圈和 for in 迴圈中沒有，所以，還是新版的 block 版本列舉器更加方便。for 迴圈中遍歷產生大量 autorelease 變數時，就需要手加區域性 autoreleasepool 咯。
5.4 什麼時候用 AutoreleasePool
- 寫基於命令列的程式時，就是沒有 UI 框架時，如 AppKit 等 Cocoa 框架。
- 寫迴圈，迴圈裡面包含了大量臨時建立的物件。
- 建立了新的執行緒。
- 長時間在後臺執行的任務。
5.5 子執行緒預設不會開啟 Runloop，那出現 Autorelease 物件如何處理？不手動處理會記憶體洩漏嗎？
這一點請參考does NSThread create autoreleasepool automaticly now? 或 各個執行緒 Autorelease 物件的記憶體管理