您现在的位置: IOS教程網 >> IOS系統 >  >> iOS 訊息 >> iOS 相關資訊

Objective-C 記憶體管理:從引用計數到 autorelease pool 的完整剖析

編輯:iOS 相關資訊

前言

剛接觸 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

细心的讀者會發現:這個物件並沒有被銷毀。那它何時銷毀、由誰銷毀?答案在下一節。

二、autorelease pool 的原理

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

四、@property (retain) 與 @synthesize 背後做了什麼

帶 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——這正是前面口訣三的由來。

五、系統自動建立的 autorelease pool

還有一個容易忽略的細節:在建立新的 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 程式碼時反而更知道編譯器在背後替你做了什麼。

  1. 上一篇文章:
  2. 下一篇文章:
蘋果刷機越獄教程| IOS教程問題解答| IOS技巧綜合| IOS7技巧| IOS8教程
Copyright © IOS教程網 All Rights Reserved