
關注倉庫,及時獲得更新:iOS-Source-Code-Analyze
Objective-C 的內存管理是個大話題,因此拆成兩篇來講:這篇聚焦自動釋放池與 autorelease 方法,另一篇則分析 retain、release 與自動引用計數。
寫在前面
本文從源碼層面梳理 Objective-C 中自動釋放池的實現,以及方法調用 autorelease 時究竟發生了什麼。
main 函數是整個 iOS 開發中最不起眼的存在,它安靜地躲在 Supporting Files 文件夾裡,卻是應用的真正入口。
// main.m
int main(int argc, char * argv[]) {
@autoreleasepool {
return UIApplicationMain(argc, argv, nil, NSStringFromClass([AppDelegate class]));
}
}
這個 @autoreleasepool block 裡只有一行代碼,把所有事件與消息都交給 UIApplication 處理——這不是本文的重點。重點是:整個 iOS 應用的生命周期都包在一個自動釋放池 block 之中。
用 clang 讓編譯器把這個文件重新寫一遍:
$ clang -rewrite-objc main.m
一堆警告之後,當前目錄多了一個 main.cpp。仔細看會發現一個古怪的結構體 __AtAutoreleasePool,註釋寫著 /* @autoreleasepool */。也就是說,@autoreleasepool {} 被翻譯成了一個 __AtAutoreleasePool 對象:
{
__AtAutoreleasePool __autoreleasepool;
}
繼續在 main.cpp 中查找這個結構體的定義:

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 語法糖的作用,僅僅是幫我們省下這兩行代碼。要理解自動釋放池,就得沿著這兩個方法往下挖。
void *objc_autoreleasePoolPush(void) {
return AutoreleasePoolPage::push();
}
void objc_autoreleasePoolPop(void *ctxt) {
AutoreleasePoolPage::pop(ctxt);
}
這兩個函數只是對 AutoreleasePoolPage 靜態方法的封裝。接下來按三個部分拆解:AutoreleasePoolPage 的結構、push 的實現、pop 的實現。
AutoreleasePoolPage 是 NSObject.mm 中的一個 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;
};
其中 magic 用於校驗當前頁的完整性,thread 記錄所屬線程。一個自動釋放池由一系列 AutoreleasePoolPage 串成,每頁大小固定為 4096 字節:
#define I386_PGBYTES 4096 #define PAGE_SIZE I386_PGBYTES
這些頁以雙向鏈表的形式連接,parent 與 child 就是鏈表指針。

假設某個 AutoreleasePoolPage 分佈在 0x100816000 ~ 0x100817000,那麼它的內存佈局是:開頭約 56 字節存放成員變量,剩下的 0x100816038 ~ 0x100817000 用來存放對象指針。

begin() 與 end() 兩個實例方法用來快速取得這段可用空間的邊界。next 始終指向下一個空位,每加入一個對象,next 就順次後移。

至於 hiwat 與 depth,它們不影響自動釋放池的核心邏輯,也不在關鍵調用棧上,這裡不展開。
POOL_SENTINEL 到底是什麼?答案樸素得讓人意外——它就是 nil 的別名。
#define POOL_SENTINEL nil
每次調用 objc_autoreleasePoolPush 創建自動釋放池時,都會把一個 POOL_SENTINEL 壓到棧頂,並把它作為返回值交給調用方。上面例子裡的 atautoreleasepoolobj 就是這個哨兵。而 objc_autoreleasePoolPop 被調用時,會從棧頂往下給每個對象發 release 消息,直到遇到第一個 POOL_SENTINEL 才停下。

static inline void *push() {
return autoreleaseFast(POOL_SENTINEL);
}
關鍵在 autoreleaseFast,它把哨兵對象作為參數傳入:
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);
}
}
三個分支對應三種情形:
最終都會走到 page->add(obj)。這裡的 hotPage 可以理解為「當前正在使用的頁」。
id *add(id obj) {
id *ret = next;
*next = obj;
next++;
return ret;
}
為方便理解,這裡做了些簡化。本質上就是壓棧:把對象寫入當前空位,然後把棧頂指針後移一格。
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);
}
它從傳入的頁出發遍歷雙向鏈表,直到找到一個未滿的頁,或者用構造器傳入 parent 新建一頁。找到可用頁後把它標記為 hotPage,再調用 add 壓入對象。
static id *autoreleaseNoPage(id obj) {
AutoreleasePoolPage *page = new AutoreleasePoolPage(nil);
setHotPage(page);
if (obj != POOL_SENTINEL) {
page->add(POOL_SENTINEL);
}
return page->add(obj);
}
此時內存中不存在任何頁,需要從頭搭建鏈表,因此新頁沒有 parent。初始化後標記為 hotPage,並先壓入一個 POOL_SENTINEL 作為兜底,保證後續 pop 不會越界,最後才把 obj 加入。
void objc_autoreleasePoolPop(void *ctxt) {
AutoreleasePoolPage::pop(ctxt);
}
從簽名看,傳入任意指針似乎都行,實踐中工程裡只見哨兵對象。不過傳入其他指針技術上可行,效果是把自動釋放池釋放到該指針對應的位置。

#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSString *s = @"Draveness";
[s stringByAppendingString:@"-Suffix"];
}
return 0;
}
在 stringByAppendingString: 這一行下斷點,因為這裡會產生一個 autorelease 對象並壓入池中。

程序停在斷點時,用 lldb 打印當前 hotPage 的棧內容:

接著把字符串 "Draveness-Suffix" 的指針傳給 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 所在頁;調用 releaseUntil 釋放棧中對象直到 stop;再根據頁面填充程度 kill 掉相應的 child 頁。
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 對齊的,所以指針對頁大小取模就能得到偏移量,減掉偏移即為頁首地址:
p = 0x100816048 p % SIZE = 0x48 result = 0x100816000
最後的 fastCheck() 用來確認 result 真的是一個 AutoreleasePoolPage,判斷依據是 magic 結構體中的某個成員是否為 0xA1A1A1A1。
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);
}
邏輯很直白:循環彈棧,直到 next 追上 stop。每彈出一個對象,先用 memset 把該位置寫成 SCRIBBLE 覆蓋指針,再調用 objc_release。遇到哨兵則跳過釋放。
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);
}
它先找到最深的子頁,然後從下往上一頁頁 delete,直到把當前頁也刪掉。
最後來看 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)
無論走哪條路徑,最終都會匯入前面分析過的 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;
}
把整條鏈路收攏一下:
自動釋放池由一系列 AutoreleasePoolPage 以雙向鏈表串接而成,每頁 4096 字節,頁內是一個向高地址生長的棧;對象調用 autorelease 時被壓入這個棧;調用 AutoreleasePoolPage::pop 時,從棧頂向棧底依次發送 release,直到遇到哨兵對象為止。
理解了這套機制,再看 ARC 下的 @autoreleasepool 語法、以及為什麼 UI 操作必須回到主線程(主線程 RunLoop 每次迭代都包著一個自動釋放池),很多問題就自然清楚了。
參考資料
What is autoreleasepool? - Objective-C / Using Autorelease Pool Blocks / NSAutoreleasePool / 黑幕背後的 Autorelease