天天看點

iOS/OS X記憶體管理(一):基本概念與原理

在Objective-C的記憶體管理中,其實就是引用計數(reference count)的管理。記憶體管理就是在程式需要時程式員配置設定一段記憶體空間,而當使用完之後将它釋放。如果程式員對記憶體資源使用不當,有時不僅會造成記憶體資源浪費,甚至會導緻程式crach。我們将會從引用計數和記憶體管理規則等基本概念開始,然後講述有哪些記憶體管理方法,最後注意有哪些常見記憶體問題。 

memory management from apple document 

為了解釋引用計數,我們做一個類比:員工在辦公室使用燈的情景。

引用Pro Multithreading and Memory Management for iOS and OS X的圖

當第一個人進入辦公室時,他需要使用燈,于是開燈,引用計數為1;

當另一個人進入辦公室時,他也需要燈,引用計數為2;每當多一個人進入辦公室時,引用計數加1;

當有一個人離開辦公室時,引用計數減1,當引用計數為0時,也就是最後一個人離開辦公室時,他不再需要使用燈,關燈離開辦公室。

從上面員工在辦公室使用燈的例子,我們對比一下燈的動作與Objective-C對象的動作有什麼相似之處:

因為我們是通過引用計數來管理燈,那麼我們也可以通過引用計數來管理使用Objective-C對象。

而Objective-C對象的動作對應有哪些方法以及這些方法對引用計數有什麼影響?

當你alloc一個對象objc,此時RC=1;在某個地方你又retain這個對象objc,此時RC加1,也就是RC=2;由于調用alloc/retain一次,對應需要調用release一次來釋放對象objc,是以你需要release對象objc兩次,此時RC=0;而當RC=0時,系統會自動調用dealloc方法釋放對象。

在開發中,我們常常都會使用到局部變量,局部變量一個特點就是當它超過作用域時,就會自動釋放。而autorelease pool跟局部變量類似,當執行代碼超過autorelease pool塊時,所有放在autorelease pool的對象都會自動調用release。它的工作原理如下:

建立一個NSAutoreleasePool對象;

在autorelease pool塊的對象調用autorelease方法;

釋放NSAutoreleasePool對象。

iOS 5/OS X Lion前的(等下會介紹引入ARC的寫法)執行個體代碼如下:

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

// put object into pool  

id obj = [[NSObject alloc] init];  

[obj autorelease];  

[pool drain];  

/* 超過autorelease pool作用域範圍時,obj會自動調用release方法 */  

由于放在autorelease pool的對象并不會馬上釋放,如果有大量圖檔資料放在這裡的話,将會導緻記憶體不足。 

for (int i = 0; i < numberOfImages; i++)  

{  

      /*   處理圖檔,例如加載 

       *   太多autoreleased objects存在 

       *   由于NSAutoreleasePool對象沒有被釋放 

       *   在某個時刻,會導緻記憶體不足  

       */  

}  

iOS/OS X記憶體管理方法有兩種:手動引用計數(Manual Reference Counting)和自動引用計數(Automatic Reference Counting)。從OS X Lion和iOS 5開始,不再需要程式員手動調用retain和release方法來管理Objective-C對象的記憶體,而是引入一種新的記憶體管理機制Automatic Reference Counting(ARC),簡單來說,它讓編譯器來代替程式員來自動加入retain和release方法來持有和放棄對象的所有權。

在ARC記憶體管理機制中,id和其他對象類型變量必須是以下四個ownership qualifiers其中一個來修飾:

__strong(預設,如果不指定其他,編譯器就預設加入)

__weak

__unsafe_unretained

__autoreleasing

是以在管理Objective-C對象記憶體的時候,你必須選擇其中一個,下面會用一些列子來逐個解釋它們的含義以及如何選擇它們。

如果我想建立一個字元串,使用完之後将它釋放調用,使用MRC管理記憶體的寫法應該是這樣:

    NSString *text = @"Hello, world";    //@"Hello, world"對象的RC=1  

    NSLog(@"%@", text);  

    [text release];                      //@"Hello, world"對象的RC=0  

而如果是使用ARC方式的話,就text對象無需調用release方法,而是當text變量超過作用域時,編譯器來自動加入[text release]方法來釋放記憶體。 

/* 

 *  當text超過作用域時,@"Hello, world"對象會自動釋放,RC=0 

 */  

而當你将text指派給其他變量anotherText時,MRC需要retain一下來持有所有權,當text和anotherText使用完之後,各個調用release方法來釋放。 

    NSString *anotherText = text;        //@"Hello, world"對象的RC=1  

    [anotherText retain];                //@"Hello, world"對象的RC=2  

    NSLog(@"%@", anotherText);  

    [text release];                      //@"Hello, world"對象的RC=1  

    [anotherText release];               //@"Hello, world"對象的RC=0  

而使用ARC的話,并不需要調用retain和release方法來持有跟釋放對象。 

    NSString *anotherText = text;        //@"Hello, world"對象的RC=2  

 *  當text和anotherText超過作用域時,會自動調用[text release]和[anotherText release]方法, @"Hello, world"對象的RC=0 

除了當__strong變量超過作用域時,編譯器會自動加入release語句來釋放記憶體,如果你将__strong變量重新賦給它其他值,那麼編譯器也會自動加入release語句來釋放變量指向之前的對象。例如: 

    NSString *anotherText = @"Sam Lau";  // 由于anotherText對象引用另一個對象@"Sam Lau",那麼就會自動調用[anotherText release]方法,使得@"Hello, world"對象的RC=1, @"Sam Lau"對象的RC=1  

 *  當text和anotherText超過作用域時,會自動調用[text release]和[anotherText release]方法, 

 *  @"Hello, world"對象的RC=0和@"Sam Lau"對象的RC=0 

如果變量var被__strong修飾,當變量var指向某個對象objc,那麼變量var持有某個對象objc的所有權。 

前面已經提過記憶體管理的四條規則: 

我們總結一下編譯器是按以下方法來實作的:

對于規則1和規則2,是通過__strong變量來實作;

對于規則3來說,當變量超過它的作用域或被指派或成員變量被丢棄時就能實作;

對于規則4,當RC=0時,系統就會自動調用。

其實編譯器根據__strong修飾符來管理對象記憶體。但是__strong并不能解決引用循環(Reference Cycle)問題:對象A持有對象B,反過來,對象B持有對象A;這樣會導緻不能釋放記憶體造成記憶體洩露問題。

舉一個簡單的例子,有一個類Test有個屬性objc,有兩個對象test1和test2的屬性objc互相引用test1和test2:

@interface Test : NSObject  

@property (strong, nonatomic) id objc;  

@end  

    Test *test1 = [Test new];        /* 對象a */  

    /* test1有一個強引用到對象a */  

    Test *test2 = [Test new];        /* 對象b */  

    /* test2有一個強引用到對象b */  

    test1.objc = test2;              /* 對象a的成員變量objc有一個強引用到對象b */  

    test2.objc = test1;              /* 對象b的成員變量objc有一個強引用到對象a */  

/*   當變量test1超過它作用域時,它指向a對象會自動release 

 *   當變量test2超過它作用域時,它指向b對象會自動release 

 *    

 *   此時,b對象的objc成員變量仍持有一個強引用到對象a 

 *   此時,a對象的objc成員變量仍持有一個強引用到對象b 

 *   于是發生記憶體洩露 

如何解決?于是我們引用一個__weakownership qualifier,被它修飾的變量都不持有對象的所有權,而且當變量指向的對象的RC為0時,變量設定為nil。例如: 

__weak NSString *text = @"Sam Lau";  

NSLog(@"%@", text);  

由于text變量被__weak修飾,text并不持有@"Sam Lau"對象的所有權,@"Sam Lau"對象一建立就馬上被釋放,并且編譯器給出警告️,是以列印結果為(null)。

是以,針對剛才的引用循環問題,隻需要将Test類的屬性objc設定weak修飾符,那麼就能解決。

@property (weak, nonatomic) id objc;  

    test1.objc = test2;              /* 對象a的成員變量objc不持有對象b */  

    test2.objc = test1;              /* 對象b的成員變量objc不持有對象a */  

__unsafe_unretained ownership qualifier,正如名字所示,它是不安全的。它跟__weak相似,被它修飾的變量都不持有對象的所有權,但當變量指向的對象的RC為0時,變量并不設定為nil,而是繼續儲存對象的位址;這樣的話,對象有可能已經釋放,但繼續通路,就會造成非法通路(Invalid Access)。例子如下:

__unsafe_unretained id obj0 = nil;  

    id obj1 = [[NSObject alloc] init];     // 對象A  

    /* 由于obj1是強引用,是以obj1持有對象A的所有權,對象A的RC=1 */  

    obj0 = obj1;  

    /* 由于obj0是__unsafe_unretained,它不持有對象A的所有權,但能夠引用它,對象A的RC=1 */  

    NSLog(@"A: %@", obj0);  

/* 當obj1超過它的作用域時,它指向的對象A将會自動釋放 */  

NSLog(@"B: %@", obj0);  

/* 由于obj0是__unsafe_unretained,當它指向的對象RC=0時,它會繼續儲存對象的位址,是以兩個位址相同 */  

列印結果是記憶體位址相同: 

如果将__unsafe_unretained改為weak的話,兩個列印結果将不同。 

__weak id obj0 = nil;  

/* 由于obj0是__weak, 當它指向的對象RC=0時,它會自動設定為nil,是以兩個列印結果将不同*/  

引入ARC之後,讓我們看看autorelease pool有哪些變化。沒有ARC之前的寫法如下:

引入ARC之後,寫法比之前更加簡潔: 

@autoreleasepool {  

    id __autoreleasing obj = [[NSObject alloc] init];  

相比之前的建立、使用和釋放NSAutoreleasePool對象,現在你隻需要将代碼放在@autoreleasepool塊即可。你也不需要調用autorelease方法了,隻需要用__autoreleasing修飾變量即可。 

引用Pro Multithreading and Memory Management for iOS and OS X的圖 

但是我們很少或基本上不使用autorelease pool。當我們使用XCode建立工程後,有一個app的入口檔案main.m使用了它: 

int main(int argc, char * argv[]) {  

    @autoreleasepool {  

        return UIApplicationMain(argc, argv, nil, NSStringFromClass([AppDelegate class]));  

    }  

有了ARC之後,新的property modifier也被引入到Objective-C類的property,例如:

@property (strong, nonatomic) NSString *text;  

下面有張表來展示property modifier與ownership qualifier的對應關系:

要想掌握iOS/OS X的記憶體管理,首先要深入了解引用計數(Reference Count)這個概念以及記憶體管理的規則;在沒引入ARC之前,我們都是通過retain和release方法來手動管理記憶體,但引入ARC之後,我們可以借助編譯器來幫忙自動調用retain和release方法來簡化記憶體管理和減低出錯的可能性。雖然__strong修飾符能夠執行大多數記憶體管理,但它不能解決引用循環(Reference Cycle)問題,于是又引入另一個修飾符__weak。被__strong修飾的變量都持有對象的所有權,而被__weak修飾的變量并不持有對象所有權。下篇我們介紹使用工具如何解決常見記憶體問題:野指針和記憶體洩露。

<a target="_blank" href="http://book.douban.com/subject/10536953/">Pro Multithreading and Memory Management for iOS and OS X</a>

<a target="_blank" href="https://developer.apple.com/library/mac/documentation/Cocoa/Conceptual/MemoryMgmt/Articles/MemoryMgmt.html#//apple_ref/doc/uid/10000011-SW1">Advanced Memory Management Programming Guide</a>