剛接觸 Objective-C 的人幾乎都有一個共同的困惑:這套記憶體管理機制實在不好捉摸,程式動不動就洩漏,不然就是莫名崩潰。本文把機制從頭梳理一遍,由淺入深,希望讀完之後你對「誰該釋放什麼」會有一套清楚的判斷依據。以下討論以繼承自 NSObject 的類別為主。
Objective-C 的記憶體管理與 .NET、Java 那種全自動的垃圾回收不同,本質上仍是 C 語言的手動管理,只是加了一些自動化的輔助機制。
1. 物件誕生於堆上,需要指標指向它。
ClassA *obj1 = [[ClassA alloc] init];
2. 物件用完不會自動銷毀,得呼叫 dealloc 釋放空間,否則就洩漏。
這帶來一個問題:如果兩個指標指向同一個物件,該由誰釋放?
ClassA *obj1 = [[ClassA alloc] init]; ClassA *obj2 = obj1; [obj1 hello]; // 輸出 hello [obj1 dealloc]; [obj2 hello]; // 還能執行嗎? [obj2 dealloc]; // 還能執行嗎?
答案是不能。obj1 與 obj2 只是指標,指向同一個物件;[obj1 dealloc] 已經把它銷毀,後面兩行都會出事。此時 obj2 是個無效指標(dangling pointer)。要避免這種情況,看下一點。
3. 引用計數(retain count)。物件內部保存一個數字,代表被引用的次數。若某物件被兩個指標指向,它的 retain count 就是 2。要銷毀物件時不直接呼叫 dealloc,而是呼叫 release;release 讓 retain count 減 1,只有減到 0,系統才會自動呼叫 dealloc 真正銷毀物件。
ClassA *obj1 = [[ClassA alloc] init]; // retain count = 1 [obj1 release]; // retain count = 0,dealloc 被自動呼叫
那把 dealloc 換成 release,剛才的問題解決了嗎?並沒有——[obj1 release] 之後 obj2 依然是無效指標。
4. 指標賦值不會自動增加 retain count,必須手動 retain。
ClassA *obj1 = [[ClassA alloc] init]; // retain count = 1 ClassA *obj2 = obj1; // retain count 仍是 1 [obj2 retain]; // retain count = 2 [obj1 hello]; // 輸出 hello [obj1 release]; // retain count = 1 [obj2 hello]; // 輸出 hello,安全 [obj2 release]; // retain count = 0,物件銷毀
問題這才真正解決。反過來說,如果忘了最後那句 [obj2 release],retain count 永遠停在 1,物件不會被回收,也就洩漏了。
5. autorelease pool。在遵守規則的前提下,可以讓物件延後自動釋放,不必到處手寫 release。
ClassA *obj1 = [[[ClassA alloc] init] autorelease]; // retain count = 1,無需再 release ClassA *obj2 = obj1; [obj2 retain]; // retain count = 2 [obj1 hello]; // obj1 這邊不用(也不能)呼叫 release [obj2 hello]; [obj2 release]; // retain count = 1
细心的讀者會發現:這個物件並沒有被銷毀。那它何時銷毀、由誰銷毀?答案在下一節。
1. autorelease pool 不是天生就有的,必須手動建立;只是用 Xcode 新增專案時,它會自動幫你寫好。它的正式名稱是 NSAutoreleasePool。
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
2. NSAutoreleasePool 內部含一個陣列(實作上是 NSMutableArray 一類的容器),用來保存所有被宣告為 autorelease 的物件。當你對一個物件呼叫 autorelease,系統做的事就是把它放進這個陣列。
3. 當 pool 自己被銷毀時,它會遍歷這個陣列,對每個成員送一次 release。若此時某成員的 retain count 為 1,release 之後歸零,物件正式銷毀;若 retain count 大於 1,release 之後仍大於 0,物件存活下來——這就是洩漏。
4. 預設只有一個 autorelease pool,通常長得像這樣:
int main(int argc, const char *argv[]) {
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
// do something
[pool release];
return 0;
}
所有標記為 autorelease 的物件,都要等到這個 pool 銷毀時才會被回收。如果你一次產生大量 autorelease 物件,記憶體用量就會一路攀升,在 iPhone 這種記憶體受限的環境裡特別容易出問題:
int main(int argc, const char *argv[]) {
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
int i, j;
for (i = 0; i < 100; i++) {
for (j = 0; j < 100000; j++) {
[NSString stringWithFormat:@"1234567890"]; // 產生的都是 autorelease 物件
}
}
[pool release];
return 0;
}
用 Instruments 跑一下,會看到記憶體持續飆高,直到 pool 銷毀才一口氣釋放。
5. autorelease pool 可以嵌套。在需要大量建立區域變數的迴圈裡,內層再包一個 pool,就能及時釋放記憶體:
int main(int argc, const char *argv[]) {
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
int i, j;
for (i = 0; i < 100; i++) {
NSAutoreleasePool *loopPool = [[NSAutoreleasePool alloc] init];
for (j = 0; j < 100000; j++) {
[NSString stringWithFormat:@"1234567890"];
}
[loopPool release];
}
[pool release];
return 0;
}
加上內層 pool 之後,記憶體曲線就平穩多了。
口訣一:誰建立,誰釋放。如果你用 alloc、new 或 copy 建立物件,就必須對它呼叫 release 或 autorelease。反過來說,不是你建立的,就不必你去釋放。在函式裡 alloc 且只在本函式使用的物件,就在本函式釋放;在類別方法裡 alloc 的成員物件若沒呼叫 autorelease,就在 dealloc 裡 release,若呼叫了 autorelease,dealloc 裡什麼都不用做。
口訣二:除了 alloc、new、copy 以外的方法所建立的物件,都已經被宣告為 autorelease。
口訣三:誰 retain,誰 release。只要呼叫過 retain,無論物件從何而來,都要對它 release。有些時候你的程式碼裡明明沒寫 retain,但系統會在預設實作中幫你 retain 一次——這一點蘋果的文件強調得不多,卻非常關鍵,下一節會說明。
以下幾個範式照著寫就不會出錯:
// 建立物件
ClassA *obj1 = [[ClassA alloc] init];
// 建立 autorelease 物件
ClassA *obj2 = [[[ClassA alloc] init] autorelease];
// release 之後立刻把指標清空(release 空指標是合法的,且不會有任何作用)
[obj1 release];
obj1 = nil;
// 指標賦值給另一個指標
ClassA *obj3 = obj1;
[obj3 retain];
// do something
[obj3 release];
obj3 = nil;
// 在函式中建立並回傳物件,記得設為 autorelease
ClassA *Func1(void) {
ClassA *obj = [[[ClassA alloc] init] autorelease];
return obj;
}
// 子類的 dealloc 記得呼叫基類的 dealloc
- (void)dealloc {
[super dealloc];
}
至於 property,標準寫法如下:
@interface ClassA : NSObject {
ClassB *objB;
}
@property (retain) ClassB *objB;
@end
@implementation ClassA
@synthesize objB;
- (void)dealloc {
[objB release];
[super dealloc];
}
@end
除了 dealloc 以外,一律用 self.objB 或 objA.objB 這種點語法存取 property。賦值時有兩種寫法:
void funcNoAutorelease(void) {
ClassB *objB1 = [[ClassB alloc] init];
ClassA *objA = [[ClassA alloc] init];
objA.objB = objB1;
[objB1 release];
[objA release];
}
void funcAutorelease(void) {
ClassB *objB1 = [[[ClassB alloc] init] autorelease];
ClassA *objA = [[[ClassA alloc] init] autorelease];
objA.objB = objB1;
}
帶 retain 參數的 property,編譯器為你合成的是一對 getter 與 setter,等價寫法如下:
@interface ClassA : NSObject {
ClassB *objB;
}
- (ClassB *)getObjB;
- (void)setObjB:(ClassB *)value;
@end
@implementation ClassA
- (ClassB *)getObjB {
return objB;
}
- (void)setObjB:(ClassB *)value {
if (objB != value) {
[objB release];
objB = [value retain];
}
}
@end
setter 裡必須先把原值 release 一次,retain count 才會正確。也因為在 class 內部(透過預設實作)確實 retain 了一次,dealloc 裡就得對應地 release——這正是前面口訣三的由來。
還有一個容易忽略的細節:在建立新的 RunLoop 時,系統會自動幫你建立新的 autorelease pool。這裡說的不是 Xcode 產生專案時寫進 main 的那一個(那段程式碼是可以刪掉的),而是系統自己建立的,在沒有垃圾回收的環境下你無法移除它。
蘋果沒有公開實作,但我們可以用一個小程式證明。先手動建立一個 pool,在其中產生一個 autorelease 的 ClassA 實例;接著在一個新的 RunLoop 中(我們並沒有手動建立 pool)產生一個 autorelease 的 ClassB:
int main(int argc, char **argv) {
NSLog(@"create an autoreleasePool");
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
NSLog(@"create an instance of ClassA and autorelease");
ClassA *obj1 = [[[ClassA alloc] init] autorelease];
NSDate *now = [[NSDate alloc] init];
NSTimer *timer = [[NSTimer alloc] initWithFireDate:now
interval:0.0
target:obj1
selector:@selector(createClassB)
userInfo:nil
repeats:NO];
NSRunLoop *runLoop = [NSRunLoop currentRunLoop];
[runLoop addTimer:timer forMode:NSDefaultRunLoopMode];
[timer release];
[now release];
[runLoop run]; // 在新的 loop 中呼叫 createClassB,產生 ClassB 的 autorelease 實例
NSLog(@"releasing autoreleasePool");
[pool release];
NSLog(@"autoreleasePool is released");
return 0;
}
輸出順序如下:
create an autoreleasePool create an instance of ClassA and autorelease create an instance of ClassB and autorelease ClassB destroyed releasing autoreleasePool ClassA destroyed autoreleasePool is released
重點在最後三行:在我們手動銷毀 pool 之前,ClassB 就已經被銷毀了。這說明 RunLoop 在每一輪迭代中確實自行建立並釋放了一個 autorelease pool,obj1 則由我們自己的 pool 持有,所以活得更久。
理解這套機制之後,多執行緒環境下的規則也就順理成章:背景執行緒若沒有 RunLoop,就必須自己包一層 autorelease pool,否則 autorelease 物件會一直累積到執行緒結束才釋放。到了 ARC 時代,retain 與 release 由編譯器代勞,@autoreleasepool 語法取代了手動的 NSAutoreleasePool,但底層的引用計數邏輯完全沒有改變——搞懂這一篇,寫 ARC 程式碼時反而更知道編譯器在背後替你做了什麼。