初學 Objective-C 的人常覺得記憶體管理摸不透,程式動不動就洩漏或莫名崩潰。這篇由淺入深把機制拆開講清楚。以下內容針對繼承自 NSObject 的類別。
Objective-C 的記憶體管理本質仍是 C 的手動方式,只是加了些自動化輔助,和 .NET / Java 的全自動垃圾回收不同。
1. 物件生在堆上,需要指標指向它。
ClassA *obj1 = [[ClassA alloc] init];
2. 物件用完不會自動銷毀。 需要執行 dealloc 釋放空間,否則洩漏。但這帶來一個問題:兩個指標指向同一物件時,該由誰 dealloc?
ClassA *obj1 = [[ClassA alloc] init]; ClassA *obj2 = obj1; [obj1 hello]; [obj1 dealloc]; [obj2 hello]; // 不能這樣寫 [obj2 dealloc];
因為 obj1 與 obj2 只是指標,指向同一物件。obj1 dealloc 之後物件已消失,obj2 就變成無效指標。
3. 於是引入引用計數(retain count)。 物件內部保存一個數字表示被引用的次數。銷毀時不直接呼叫 dealloc,而是呼叫 release 讓計數減一;只有計數歸零,系統才會呼叫 dealloc。
ClassA *obj1 = [[ClassA alloc] init]; // retain count = 1 [obj1 release]; // 減到 0,dealloc 自動被呼叫
把上面的無效指標範例改成 release 也沒用:obj1 release 之後 obj2 依然是無效指標。
4. 指標賦值不會自動增加計數,需要手動 retain。
ClassA *obj1 = [[ClassA alloc] init]; // 1 ClassA *obj2 = obj1; // 仍是 1 [obj2 retain]; // 2 [obj1 hello]; [obj1 release]; // 1 [obj2 hello]; [obj2 release]; // 0,物件被銷毀
注意:若少了 [obj2 release],計數永遠停在 1,物件不會被銷毀,也就洩漏了。
每次都要算計數太麻煩,於是有了自動釋放池。在遵守規則的前提下,可以延後釋放物件。
規則一:新產生的物件只要送 autorelease,就不必再 release。
ClassA *obj1 = [[[ClassA alloc] init] autorelease];
規則二:存在指標賦值時,被多持有的那一方仍要自己 release。
ClassA *obj1 = [[[ClassA alloc] init] autorelease]; // 1 ClassA *obj2 = obj1; // 1 [obj2 retain]; // 2 [obj1 hello]; // obj1 無需也不能 release [obj2 hello]; [obj2 release]; // 1
這時計數停在 1,物件還沒銷毀。誰來收尾?答案在 pool。
NSAutoreleasePool 內部維護一個陣列(NSMutableArray),用來保存所有被宣告為 autorelease 的物件。當 pool 自己被釋放時,會遍歷這個陣列,對每個成員送一次 release。若此時成員計數為 1,release 後歸零、物件正式銷毀;若計數大於 1,release 後仍大於 0,物件存活,也就洩漏了。
預設只有一個 pool,通常由 main 函數建立:
int main(int argc, const char *argv[]) {
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
// do something
[pool release];
return 0;
}
問題來了:所有標記為 autorelease 的物件都要等這個 pool 銷毀才釋放。若你在迴圈裡大量產生 autorelease 物件:
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;
}
記憶體會一路攀升直到 pool 銷毀才一次釋放。在記憶體受限的行動裝置上,這很容易造成不足。
解法是巢狀建立 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;
}
這樣記憶體佔用幾乎是平的。ARC 環境下改用 @autoreleasepool { ... } 表達同一件事。
arrayWithObjects:)產生的物件,都已經是 autorelease 的,你不必管。
// 建立物件
ClassA *obj1 = [[ClassA alloc] init];
// 建立 autorelease 物件
ClassA *obj1 = [[[ClassA alloc] init] autorelease];
// release 後立刻清空指標(對空指標 release 合法且無副作用)
[obj1 release];
obj1 = nil;
// 指標賦值給另一個指標
ClassA *obj2 = obj1;
[obj2 retain];
// do something
[obj2 release];
obj2 = nil;
// 函數中建立並回傳物件,記得設為 autorelease
ClassA *Func1() {
ClassA *obj = [[[ClassA alloc] init] autorelease];
return obj;
}
// 子類 dealloc 中呼叫基類 dealloc
- (void)dealloc {
[super dealloc];
}
@interface ClassA : NSObject
{
ClassB *objB;
}
@property (retain) ClassB *objB;
@end
@implementation ClassA
@synthesize objB;
- (void)dealloc
{
[objB release];
[super dealloc];
}
@end
除了 dealloc,其餘地方一律用 self.objB 這種點語法存取。賦值時兩種寫法都可以:
void funcNoAutorelease() {
ClassB *objB1 = [[ClassB alloc] init];
ClassA *objA = [[ClassA alloc] init];
objA.objB = objB1;
[objB1 release];
[objA release];
}
void funcAutorelease() {
ClassB *objB1 = [[[ClassB alloc] init] autorelease];
ClassA *objA = [[[ClassA alloc] init] autorelease];
objA.objB = objB1;
}
@property (retain) 加 @synthesize 背後其實就是一對 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 新值,計數才會正確。因為 class 內部(透過預設實作)已經 retain 了一次,所以 dealloc 中要對應 release。
在建立新的 Run Loop 時,系統會自動產生新的 autorelease pool。這與 Xcode 專案模板裡那段可以刪除的 pool 不同——系統自動建立的無法刪除(在非垃圾回收環境下)。官方沒有公開實作程式碼,但可以用小程式驗證:
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 中產生 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 <-- 在我們的 pool 之前就被釋放了 releasing autoreleasePool ClassA destroyed autoreleasePool is released
ClassB 比 ClassA 更早銷毀,說明它並非由我們手動建立的 pool 回收,而是被 Run Loop 每輪迭代自動建立的 pool 收走了。這解釋了為什麼在 run loop 中產生的暫時物件通常不會累積成記憶體問題。
以上機制在 ARC 中完全沒有消失,只是 retain / release / autorelease 由編譯器代為插入。ARC 之下你不能自己呼叫這些方法,也不該在 dealloc 中寫 [super dealloc];retain 屬性改寫成 strong,基本型別仍用 assign,copy 不變,而循環引用的兩端要一端 strong、一端 weak。pool 則統一寫成 @autoreleasepool { }。理解 MRC 的規則,才能解釋 ARC 為何在某些寫法下仍會洩漏。