您现在的位置: IOS教程網 >> IOS系統 >  >> iOS 程式開發 >> iOS 開發綜合

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

編輯:iOS 開發綜合

初學 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 pool

每次都要算計數太麻煩,於是有了自動釋放池。在遵守規則的前提下,可以延後釋放物件。

規則一:新產生的物件只要送 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。

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 { ... } 表達同一件事。

三、口訣與範式

口訣

  • 誰建立,誰釋放。 用 alloc / new / copy 產生的物件,必須由你 release 或 autorelease。不是你建立的,就不用你釋放。
  • 除了 alloc / new / copy 以外的方法(如 arrayWithObjects:)產生的物件,都已經是 autorelease 的,你不必管。
  • 誰 retain,誰 release。 只要呼叫過 retain,無論物件怎麼來,都要對應一次 release。這點常被忽略:系統在 property 的預設 setter 中就會幫你 retain。

範式

// 建立物件
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];
}

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 這種點語法存取。賦值時兩種寫法都可以:

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 預設 setter 到底做了什麼

@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。

五、系統也會自動建立 pool

在建立新的 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 之後

以上機制在 ARC 中完全沒有消失,只是 retain / release / autorelease 由編譯器代為插入。ARC 之下你不能自己呼叫這些方法,也不該在 dealloc 中寫 [super dealloc];retain 屬性改寫成 strong,基本型別仍用 assign,copy 不變,而循環引用的兩端要一端 strong、一端 weak。pool 則統一寫成 @autoreleasepool { }。理解 MRC 的規則,才能解釋 ARC 為何在某些寫法下仍會洩漏。

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