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

iOS 開發(29)之 Objective-C 內存管理原理剖析

編輯:iOS 開發綜合

轉自:iPhone/Mac Objective-C 內存管理教程和原理剖析

1 前言

剛接觸 Objective-C 的朋友多半有過這樣的困惑:总觉得內存管理機制難以捉摸,程序要麼洩露要麼莫名崩潰。本文把引用計數這套機制的原理由淺入深梳理一遍,希望能替你把这些疑惑理清楚。

以下討論的內存管理,都是針對繼承自 NSObject 的類別。

2 基本原理

Objective-C 的內存管理與 .Net、Java 那種全自動垃圾回收不同,本質上仍是 C 語言的手動管理,只是加上了一些自動化的輔助手段。

2.1 對象誕生於堆上

生成之後需要一個指針指向它。

ClassA *obj1 = [[ClassA alloc] init];

2.2 用完必須主動銷毀

Objective-C 的對象不會在使用完畢後自動消失,必須呼叫 dealloc 釋放空間,否則就是洩露。

[obj1 dealloc];

但這帶來一個問題。看下面這段代碼,obj2 需要呼叫 dealloc 嗎?

ClassA *obj1 = [[ClassA alloc] init];
ClassA *obj2 = obj1;

[obj1 hello];      // 輸出 hello
[obj1 dealloc];
[obj2 hello];      // 還能執行嗎?
[obj2 dealloc];

答案是不能。obj1 與 obj2 只是兩個指針,指向同一個對象;[obj1 dealloc] 已經把這個對象銷毀了,後續對 obj2 的任何調用都是訪問已釋放的內存。此時 obj2 是個不折不扣的無效指針。

2.3 引用計數(retain count)

為了解決這個問題,Objective-C 採用了引用計數機制。每個對象內部保存一個數字,表示自己被引用的次數。銷毀時不直接呼叫 dealloc,而是呼叫 release,讓計數減一;只有計數歸零,系統才會真正呼叫 dealloc。

ClassA *obj1 = [[ClassA alloc] init];  // retain count = 1
[obj1 release];                        // 減至 0,dealloc 自動觸發,對象銷毀

那麼把 dealloc 換成 release,剛才的問題解決了嗎?

ClassA *obj1 = [[ClassA alloc] init];  // retain count = 1
ClassA *obj2 = obj1;                   // retain count 仍是 1
[obj1 hello];                          // 輸出 hello
[obj1 release];                        // retain count = 0,對象銷毀
[obj2 hello];                          // 無效指針
[obj2 release];

顯然沒有。obj2 依然是無效指針。

2.4 賦值時需手動 retain

關鍵在於:Objective-C 在指針賦值時不會自動增加引用計數,需要你自己 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];                        // 2 - 1 = 1,對象存活

[obj2 hello];                          // 輸出 hello
[obj2 release];                        // 歸零,對象銷毀

問題這才真正解決。反過來說,如果少了 [obj2 release],計數會一直停在 1,對象永遠不會被釋放。

2.5 autorelease pool(自動釋放池)

每次都手動配對 release 顯得繁瑣,於是 Objective-C 引入了 autorelease pool。在遵守一定規則的前提下,對象可以被延後自動釋放。注意,它仍然不是 .Net/Java 那種全自動垃圾回收。

新規則一:剛建立的對象只要標記為 autorelease,就不必再呼叫 release。

ClassA *obj1 = [[[ClassA alloc] init] autorelease];  // retain count = 1,但無需 release

新規則二:涉及指針賦值時,寫法與前面類似。

ClassA *obj1 = [[[ClassA alloc] init] autorelease];  // retain count = 1
ClassA *obj2 = obj1;                                  // retain count = 1
[obj2 retain];                                        // retain count = 2
[obj1 hello];                                         // 輸出 hello
// obj1 無需(也不能)release
[obj2 hello];                                         // 輸出 hello
[obj2 release];                                       // 2 - 1 = 1

细心的讀者會發現,這個對象始終沒被銷毀。它何時銷毀?由誰銷毀?答案在下一節。

2.6 autorelease pool 原理剖析

其實原理很簡單。它的真名是 NSAutoreleasePool,需要手動建立——只不過新建 iOS 項目時 Xcode 已經替你寫好了。

NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

NSAutoreleasePool 內部維護一個數組(本質上是 NSMutableArray),用來存放所有被標記為 autorelease 的對象。當一個對象呼叫 autorelease 時,系統做的事就是把它加進這個數組。

ClassA *obj1 = [[[ClassA alloc] init] autorelease];  // 同時被加入 pool

而當 pool 自己被銷毀時,它會遍歷這個數組,對每個成員送出一個 release。若此時某成員的 retain count 為 1,release 後歸零,對象正式銷毀;若大於 1,release 後仍大於零,對象存活——這就是洩露的來源。

默認情況下只有一個 pool,結構大致如下:

int main (int argc, const char *argv[])
{
    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

    // do something

    [pool release];
    return 0;
}

所有標記為 autorelease 的對象,都要等到這個 pool 銷毀時才會被釋放。這在內存受限的移動設備上是個隱憂。看看下面這段:

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

這裡瞬間產生了上千萬個 autorelease 對象,全部堆在 pool 裡直到最後才釋放,內存占用會急劇攀升。

2.7 嵌套使用多個 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;
}

3 口訣與範式

3.1 三句口訣

第一,誰創建,誰釋放(類似「誰污染,誰治理」)。凡是透過 alloc、new 或 copy 建立的對象,你就有責任呼叫 release 或 autorelease;反之,不是你建立的,就不必你來釋放。舉例來說,在函數中 alloc 且只在本函數使用的對象,就必須在本函數內 release;若在類別的某方法中 alloc 了一個成員對象,則要在 dealloc 裡 release——除非你已經對它呼叫了 autorelease,那麼 dealloc 中什麼都不用做。

第二,除了 alloc、new、copy 之外的方法所建立的對象,都已經被標記為 autorelease。這意味著你不該對它們 release,否則會過早釋放。

第三,誰 retain,誰 release。只要呼叫過 retain,無論對象從何而來,都要對應一次 release。值得注意的是,有些時候你的代碼裡明明沒寫 retain,系統卻會在默認實現中替你加上——property 的 retain 修飾就是典型例子。蘋果文檔對這點著墨不多,但它非常重要。

3.2 常用範式

建立對象:

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

給 property 賦值有兩種寫法,手動 release 或 autorelease:

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

4 @property (retain) 與 @synthesize 的默認實現

那麼 @property (retain) ClassB* objB; 搭配 @synthesize objB; 背後究竟做了什麼?property 本質上就是 getter 與 setter,展開後如下:

@implementation ClassA

-(ClassB*) getObjB
{
    return objB;
}

-(void) setObjB:(ClassB*) value
{
    if (objB != value)
    {
        [objB release];
        objB = [value retain];
    }
}

@end

重點在 setter 裡:當新值與舊值不同時,必須先對舊值 release 一次,計數才會正確。也因為類別內部確實 retain 了一次(即使是由默認實現代勞),所以 dealloc 中必須對應地 release:

-(void) dealloc
{
    [objB release];
    [super dealloc];
}

5 系統會自動建立新的 autorelease pool

還有一點常被忽略:每當系統建立新的 Run Loop 時,會自動幫你準備一個 autorelease pool。這裡說的不是 Xcode 在你 main 函數裡生成的那段代碼——那段是可以刪掉的;系統自動建立的這一個則無法移除(在沒有垃圾回收的環境下)。Objective-C 沒有公開實作,但我們可以用實驗證明。

下面的程序先手動建立一個 pool,在其中產生一個 autorelease 的 ClassA 實例,然後透過 NSTimer 在一個新的 Run Loop 中產生 ClassB 的 autorelease 實例——注意,我們並沒有在新 Run Loop 裡手動建立任何 pool。

int main(int argc, char **argv)
{
    NSLog(@"create an autorelasePool\n");
    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

    NSLog(@"create an instance of ClassA and autorelease\n");
    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 autorelasePool\n");
    [pool release];
    NSLog(@"autorelasePool is released\n");
    return 0;
}

輸出如下:

create an autorelasePool
create an instance of ClassA and autorelease
create an instance of ClassB and autorelease
ClassB destroyed
releasing autorelasePool
ClassA destroyed
autorelasePool is released

請注意順序:在我們手動銷毀 pool 之前,ClassB 就已經被釋放了。

或許有人會說,這不能證明新 Run Loop 建立了新 pool,說不定只是把舊 pool drain 了一次。那我們就把 main 函數裡的 pool 完全拿掉試試。

int main(int argc, char **argv)
{
    NSLog(@"No autorelasePool created\n");

    NSLog(@"create an instance of ClassA\n");
    ClassA *obj1 = [[ClassA alloc] init];

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

    NSLog(@"Manually release the instance of ClassA\n");
    [obj1 release];
    return 0;
}

輸出如下:

No autorelasePool created
create an instance of ClassA
create an instance of ClassB and autorelease
ClassB destroyed
Manually release the instance of ClassA
ClassA destroyed

我們顯然沒有建立任何 pool,但 ClassB 的實例依然被自動銷毀了。這說明新的 Run Loop 確實自動配置了一個 autorelease pool,並在該 Run Loop 結束時將自身釋放,順帶清理裡頭的所有對象。

補充說明

研究 retain count 時,不建議拿 NSString 來實驗。因為在下面這種寫法裡:

NSString *str1 = @"constant string";

str1 的 retain count 會是個極大的數字——Objective-C 對常量字符串做了特殊處理。而如果你改用這種方式建立:

NSString *str2 = [NSString stringWithFormat:@"123"];

得到的 retain count 仍然是 1,實驗起來才會有參考價值。

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