Objective-c記憶體管理機制

著作權聲明
此文著作權歸作者Vince Yuan (vince.yuan#gmail.com)所有。歡迎非營利性轉載，轉載時必須包含原始連結http://vinceyuan.cnblogs.com/，且必須包含此著作權聲明的完整內容。
版本 1.1  發表於2010-03-08
前言

初學objectice-C的朋友都有一個困惑，總覺得對objective-C的記憶體管理機制琢磨不透，程式經常記憶體流失或莫名其妙的崩潰。我在這裡總結了自己對objective-C記憶體管理機制的研究成果和經驗，寫了這麼一個由淺入深的教程。希望對大家有所協助，也歡迎大家一起探討。
此文涉及的記憶體管理是針對於繼承於NSObject的Class。

一 基本原理

Objective-C的記憶體管理機制與.Net/Java那種全自動的記憶體回收機制是不同的，它本質上還是C語言中的手動管理方式，只不過稍微加了一些自動方法。

1           Objective-C的對象產生於堆之上，產生之後，需要一個指標來指向它。
ClassA *obj1 = [[ClassA alloc] init];

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 hello]和[obj2 dealloc]。obj2實際上是個無效指標。

         如何避免無效指標？請看下一條。

3           Objective-C採用了引用計數(ref count或者retain count)。對象的內部儲存一個數字，表示被引用的次數。例如，某個對象被兩個指標所指向（引用）那麼它的retain count為2。需要銷毀對象的時候，不直接調用dealloc，而是調用release。release會讓retain count減1，只有retain count等於0，系統才會調用dealloc真正銷毀這個對象。

ClassA *obj1 = [[ClassA alloc] init]; //對象產生時，retain count = 1

[obj1 release]; //release使retain count減1，retain count = 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];

 [obj1 release]之後，obj2依然是個無效指標。問題依然沒有解決。解決方案見下一條。

4           Objective-C指標賦值時，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 = 2 – 1 = 1

[obj2 hello]; //輸出hello

[obj2 release]; //retain count = 0，對象被銷毀

問題解決！注意，如果沒有調用[obj2 release]，這個對象的retain count始終為1，不會被銷毀，記憶體泄露。(1-4可以參考附件中的樣本程式memman-no-pool.m)

這樣的確不會記憶體泄露，但似乎有點麻煩，有沒有簡單點的方法？見下一條。

5           Objective-C中引入了autorelease pool（自動釋放對象池），在遵守一些規則的情況下，可以自動釋放對象。（autorelease pool依然不是.Net/Java那種全自動的記憶體回收機制）

5.1          新產生的對象，只要調用autorelease就行了，無需再調用release！

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

5.2          對於存在指標賦值的情況，代碼與前面類似。

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]; //retain count = 2-1 = 1

細心的讀者肯定能發現這個對象沒有被銷毀，何時銷毀呢？誰去銷毀它？（可以參考附件中的樣本程式memman-with-pool.m）請看下一條。

6           autorelease pool原理剖析。（其實很簡單的，一定要堅持看下去，否則還是不能理解Objective-C的記憶體管理機制。）

6.1          autorelease pool不是天生的，需要手動創立。只不過在建立一個iphone項目時，xcode會自動幫你寫好。autorelease pool的真名是NSAutoreleasePool。

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

6.2          NSAutoreleasePool內部包含一個數組（NSMutableArray），用來儲存聲明為autorelease的所有對象。如果一個對象聲明為autorelease，系統所做的工作就是把這個對象加入到這個數組中去。

ClassA *obj1 = [[[ClassA alloc] init] autorelease]; //retain count = 1，把此對象加入autorelease pool中

6.3          NSAutoreleasePool自身在銷毀的時候，會遍曆一遍這個數組，release數組中的每個成員。如果此時數組中成員的retain count為1，那麼release之後，retain count為0，對象正式被銷毀。如果此時數組中成員的retain count大於1，那麼release之後，retain count大於0，此對象依然沒有被銷毀，記憶體泄露。

6.4          預設只有一個autorelease pool，通常類似於下面這個例子。

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

{

NSAutoreleasePool *pool;

pool = [[NSAutoreleasePool alloc] init];

// do something

[pool release];

return (0);

} // main

所有標記為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);

} // main

（可以參考附件中的樣本程式memman-many-objs-one-pool.m，運行時通過監控工具可以發現使用的記憶體在急劇增加，直到pool銷毀時才被釋放）你需要考慮下一條。

7           Objective-C程式中可以嵌套建立多個autorelease pool。在需要大量建立局部變數的時候，可以建立內嵌的autorelease pool來及時釋放記憶體。（感謝網友hhyytt和neogui的提醒，某些情況下，系統會自動建立autorelease 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"];//產生的對象是autorelease的。

 [loopPool release];
}
[pool release];

return (0);

} // main

（可以參考附件中的樣本程式memman-many-objs-many-pools.m，佔用記憶體的變化極小）

（二）
二 口訣與範式

1           口訣。

1.1          誰建立，誰釋放（類似於“誰汙染，誰治理”）。如果你通過alloc、new或copy來建立一個對象，那麼你必須調用release或autorelease。換句話說，不是你建立的，就不用你去釋放。
例如，你在一個函數中alloc產生了一個對象，且這個對象只在這個函數中被使用，那麼你必須在這個函數中調用release或autorelease。如果你在一個class的某個方法中alloc一個成員對象，且沒有調用autorelease，那麼你需要在這個類的dealloc方法中調用release；如果調用了autorelease，那麼在dealloc方法中什麼都不需要做。

1.2          除了alloc、new或copy之外的方法建立的對象都被聲明了autorelease。

1.3          誰retain，誰release。只要你調用了retain，無論這個對象是如何產生的，你都要調用release。有時候你的代碼中明明沒有retain，可是系統會在預設實現中加入retain。不知道為什麼蘋果公司的文檔沒有強調這個非常重要的一點，請參考範式2.7和第三章。

2           範式。
範式就是模板，就是依葫蘆畫瓢。由於不同人有不同的理解和習慣，我總結的範式不一定適合所有人，但我能保證照著這樣做不會出問題。

2.1          建立一個對象。

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

2.2         建立一個autorelease的對象。

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

2.3          Release一個對象後，立即把指標清空。（順便說一句，release一個null 指標是合法的，但不會發生任何事情）

[obj1 release];

obj1 = nil;

2.4          指標賦值給另一個指標。

ClassA *obj2 = obj1;

[obj2 retain];

//do something

[obj2 release];

obj2 = nil;

2.5          在一個函數中建立並返回對象，需要把這個對象設定為autorelease

ClassA *Func1()
{
  ClassA *obj = [[[ClassA alloc]init]autorelease];

  return obj;

}

2.6          在子類的dealloc方法中調用基類的dealloc方法

-(void) dealloc

{       …

         [super dealloc];

}

2.7          在一個class中建立和使用property。

2.7.1     聲明一個成員變數。

ClassB *objB;

2.7.2     聲明property，加上retain參數。

@property (retain) ClassB* objB;

2.7.3     定義property。（property的預設實現請看第三章）

@synthesize objB;

2.7.4     除了dealloc方法以外，始終用.操作符的方式來調用property。

self.objB 或者objA.objB

2.7.5     在dealloc方法中release這個成員變數。

[objB release];

範例程式碼如下（詳細代碼請參考附件中的memman-property.m，你需要特別留意對象是在何時被銷毀的。）：

@interface ClassA : NSObject
{
         ClassB* objB;

}

@property (retain) ClassB* objB;

@end

@implementation ClassA

@synthesize objB;

-(void) dealloc
{
         [objB release];

         [super dealloc];

}
@end

2.7.6     給這個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;
}

（三）
三 @property (retain)和@synthesize的預設實現

在這裡解釋一下@property (retain) ClassB* objB;和@synthesize objB;背後到底發生了什麼(retain property的預設實現)。property實際上是getter和setter，針對有retain參數的property，背後的實現如下（請參考附件中的memman-getter-setter.m，你會發現，結果和memman-property.m一樣）：

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

在setObjB中，如果新設定的值和原值不同的話，必須要把原值對象release一次，這樣才能保證retain count是正確的。

由於我們在class內部retain了一次（雖然是預設實現的），所以我們要在dealloc方法中release這個成員變數。

-(void) dealloc
{
         [objB release];

         [super dealloc];

}

（四）
四 系統自動建立新的autorelease pool

在產生新的Run Loop的時候，系統會自動建立新的autorelease pool（非常感謝網友hhyytt和neogui的提醒）。注意，此處不同於xcode在建立項目時自動產生的程式碼中加入的autorelease pool，xcode產生的程式碼可以被刪除，但系統自動建立的新的autorelease pool是無法刪除的（對於無Garbage Collection的環境來說）。Objective-C沒有給出實現代碼，官方文檔也沒有說明，但我們可以通過小程式來證明。

在這個小程式中，我們先產生了一個autorelease pool，然後產生一個autorelease的ClassA的執行個體，再在一個新的run loop中產生一個autorelease的ClassB的對象（注意，我們並沒有手動在新run loop中產生autorelease pool）。精簡的範例程式碼如下，詳細代碼請見附件中的memman-run-loop-with-pool.m。

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

注意在我們銷毀autorelease pool之前，ClassB的autorelease執行個體就已經被銷毀了。

有人可能會說，這並不能說明新的run loop自動產生了一個新的autorelease pool，說不定還只是用了老的autorelease pool，只不過後來drain了一次而已。我們可以在main函數中不產生autorelease pool。精簡的範例程式碼如下，詳細代碼請見附件中的memman-run-loop-without-pool.m。

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]; //在新loop中調用一函數，產生ClassB的autorelease執行個體

         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

我們可以看出來，我們並沒有建立任何autorelease pool，可是ClassB的執行個體依然被自動銷毀了，這說明新的run loop自動建立了一個autorelease pool，這個pool在新的run loop結束的時候會銷毀自己（並自動release所包含的對象）。

補充說明

在研究retain count的時候，我不建議用NSString。因為在下面的語句中，
NSString *str1 = @”constant string”;
str1的retain count是個很大的數字。Objective-C對常量字串做了特殊處理。
當然，如果你這樣建立NSString，得到的retain count依然為1
NSString *str2 = [NSString stringWithFormat:@”123”];