1. 什么是內存管理

• 程序在運行的過程中通常通過以下行為，來增加程序的的內存占用
  • 創建一個OC對象
  • 定義一個變量
  • 調用一個函數或者方法
• 而一個移動設備的內存是有限的，每個軟件所能占用的內存也是有限的
• 當程序所占用的內存較多時，系統就會發出內存警告，這時就得回收一些不需要再使用的內存空間。比如回收一些不需要使用的對象、變量等
• 如果程序占用內存過大，系統可能會強制關閉程序，造成程序崩潰、閃退現象，影響用戶體驗

所以，我們需要對內存進行合理的分配內存、清除內存，回收那些不需要再使用的對象。從而保證程序的穩定性。

? ? 那么，那些對象才需要我們進行內存管理呢？

• 任何繼承了NSObject的對象需要進行內存管理
• 而其他非對象類型(int、char、float、double、struct、enum等) 不需要進行內存管理

? ? 這是因為

• 繼承了NSObject的對象的存儲在操作系統的堆里邊。
• 操作系統的堆：一般由程序員分配釋放，若程序員不釋放，程序結束時可能由OS回收，分配方式類似于鏈表
• 非OC對象一般放在操作系統的棧里面
• 操作系統的棧：由操作系統自動分配釋放，存放函數的參數值，局部變量的值等。其操作方式類似于數據結構中的棧(先進后出)
• 示例：
  int main(int argc, const char * argv[]) {@autoreleasepool {int a = 10; // 棧int b = 20; // 棧// p : 棧// Person對象(計數器==1) : 堆Person *p = [[Person alloc] init];}// 經過上面代碼后, 棧里面的變量a、b、p 都會被回收// 但是堆里面的Person對象還會留在內存中,因為它是計數器依然是1return 0; }?

---

2. 內存管理模型

提供給Objective-C程序員的基本內存管理模型有以下3種：

• 自動垃圾收集（iOS運行環境不支持）
• 手工引用計數和自動釋放池(MRC)
• 自動引用計數(ARC)

---

3.MRC 手動管理內存(Manual Reference Counting)

1. 引用計數器

系統是根據對象的引用計數器來判斷什么時候需要回收一個對象所占用的內存

• 引用計數器是一個整數
• 從字面上, 可以理解為”對象被引用的次數”
• 也可以理解為: 它表示有多少人正在用這個對象
• 每個OC對象都有自己的引用計數器
• 任何一個對象，剛創建的時候，初始的引用計數為1
  • 當使用alloc、new或者copy創建一個對象時，對象的引用計數器默認就是1
• 當沒有任何人使用這個對象時，系統才會回收這個對象, 也就是說
  • 當對象的引用計數器為0時，對象占用的內存就會被系統回收
  • 如果對象的計數器不為0，那么在整個程序運行過程，它占用的內存就不可能被回收(除非整個程序已經退出 )

2. 引用計數器操作

• 為保證對象的存在，每當創建引用到對象需要給對象發送一條retain消息，可以使引用計數器值+1 ( retain 方法返回對象本身)
• 當不再需要對象時，通過給對象發送一條release消息，可以使引用計數器值-1
• 給對象發送retainCount消息，可以獲得當前的引用計數器值
• 當對象的引用計數為0時，系統就知道這個對象不再需要使用了，所以可以釋放它的內存，通過給對象發送dealloc消息發起這個過程。
• 需要注意的是：release并不代表銷毀\回收對象，僅僅是計數器-1

int main(int argc, const char * argv[]) {@autoreleasepool {// 只要創建一個對象默認引用計數器的值就是1Person *p = [[Person alloc] init];NSLog(@"retainCount = %lu", [p retainCount]); // 1// 只要給對象發送一個retain消息, 對象的引用計數器就會+1 [p retain];NSLog(@"retainCount = %lu", [p retainCount]); // 2// 通過指針變量p,給p指向的對象發送一條release消息// 只要對象接收到release消息, 引用計數器就會-1// 只要一個對象的引用計數器為0, 系統就會釋放對象 [p release];// 需要注意的是: release并不代表銷毀\回收對象, 僅僅是計數器-1NSLog(@"retainCount = %lu", [p retainCount]); // 1 [p release]; // 0NSLog(@"--------");} // [p setAge:20]; // 此時對象已經被釋放return 0; }

3. dealloc方法

• 當一個對象的引用計數器值為0時，這個對象即將被銷毀，其占用的內存被系統回收
• 對象即將被銷毀時系統會自動給對象發送一條dealloc消息(因此，從dealloc方法有沒有被調用,就可以判斷出對象是否被銷毀)
• dealloc方法的重寫
  • 一般會重寫dealloc方法，在這里釋放相關資源，dealloc就是對象的遺言
  • 一旦重寫了dealloc方法，就必須調用[super dealloc]，并且放在最后面調用

- (void)dealloc {NSLog(@"Person dealloc");// 注意:super dealloc一定要寫到所有代碼的最后// 一定要寫在dealloc方法的最后面 [super dealloc]; }

• 使用注意
  • 不能直接調用dealloc方法
  • 一旦對象被回收了, 它占用的內存就不再可用，堅持使用會導致程序崩潰（野指針錯誤）

4. 野指針和空指針

• 只要一個對象被釋放了，我們就稱這個對象為 "僵尸對象(不能再使用的對象)"
• 當一個指針指向一個僵尸對象(不可用內存)，我們就稱這個指針為野指針
• 只要給一個野指針發送消息就會報錯(EXC_BAD_ACCESS錯誤)

int main(int argc, const char * argv[]) {@autoreleasepool {Person *p = [[Person alloc] init]; // 執行完引用計數為1 [p release]; // 執行完引用計數為0，實例對象被釋放[p release]; // 此時，p就變成了野指針，再給野指針p發送消息就會報錯 [p release];}return 0; }

• 為了避免給野指針發送消息會報錯，一般情況下，當一個對象被釋放后我們會將這個對象的指針設置為空指針
• 空指針
  • 沒有指向存儲空間的指針(里面存的是nil, 也就是0)
  • 給空指針發消息是沒有任何反應的

int main(int argc, const char * argv[]) {@autoreleasepool {Person *p = [[Person alloc] init]; // 執行完引用計數為1 [p release]; // 執行完引用計數為0，實例對象被釋放p = nil; // 此時，p變為了空指針[p release]; // 再給空指針p發送消息就不會報錯了 [p release];}return 0; }

?

5. 內存管理規律

單個對象內存管理規律

• 誰創建誰release :
  • 如果你通過alloc、new、copy或mutableCopy來創建一個對象，那么你必須調用release或autorelease
• 誰retain誰release:
  • 只要你調用了retain，就必須調用一次release
• 總結一下就是
  • 有加就有減
  • 曾經讓對象的計數器+1，就必須在最后讓對象計數器-1

多個對象內存管理規律

因為多個對象之間往往是聯系的，所以管理起來比較復雜。這里用一個玩游戲例子來類比一下。

游戲可以提供給玩家(A類對象) 游戲房間(B類對象)來玩游戲。

• 只要一個玩家想使用房間(進入房間)，就需要對這個房間的引用計數器+1
• 只要一個玩家不想再使用房間(離開房間)，就需要對這個房間的引用計數器-1
• 只要還有至少一個玩家在用某個房間，那么這個房間就不會被回收，引用計數至少為1

下面來定義兩個類 玩家類：Person 和 房間類：Room

房間類：Room，房間類中有房間號

#import <Foundation/Foundation.h>@interface Room : NSObject @property int no; // 房間號 @end

玩家類：Person

#import <Foundation/Foundation.h> #import "Room.h"@interface Person : NSObject {Room *_room; }- (void)setRoom:(Room *)room;- (Room *)room; @end

現在我們通過幾個玩家使用房間的不同應用場景來逐步深入理解內存管理。

1. 玩家沒有使用房間，玩家和房間之間沒有聯系的情況

int main(int argc, const char * argv[]) {@autoreleasepool {// 1.創建兩個對象Person *p = [[Person alloc] init]; // 玩家 pRoom *r = [[Room alloc] init]; // 房間 rr.no = 888; // 房間號賦值 [r release]; // 釋放房間 [p release]; // 釋放玩家 }return 0; }

上述代碼執行完前3行

// 1.創建兩個對象Person *p = [[Person alloc] init]; // 玩家 pRoom *r = [[Room alloc] init]; // 房間 rr.no = 888; // 房間號賦值

之后在內存中的表現如下圖所示：

可見，Room實例對象和Person實例對象之間沒有相互聯系，所以各自釋放不會報錯。執行完4、5行代碼 [r release]; // 釋放房間 [p release]; // 釋放玩家

后，將房間對象和玩家對象各自釋放掉，在內存中的表現如下圖所示：

最后各自實例對象的內存就會被系統回收

2. 一個玩家使用一個游戲房間，玩家和房間之間相關聯的情況

int main(int argc, const char * argv[]) {@autoreleasepool {// 1.創建兩個對象Person *p = [[Person alloc] init]; // 玩家 pRoom *r = [[Room alloc] init]; // 房間 rr.no = 888; // 房間號賦值// 將房間賦值給玩家，表示玩家在使用房間// 玩家需要使用這間房，只要玩家在，房間就一定要在p.room = r; // [p setRoom:r] [r release]; // 釋放房間// 在這行代碼之前，玩家都沒有被釋放，但是因為玩家還在，那么房間就不能銷毀NSLog(@"-----");[p release]; // 釋放玩家 }return 0; }

上邊代碼執行完前3行的時候和之前在內存中的表現一樣，如圖

當執行完第4行代碼p.room = r;時，因為調用了setter方法，將Room實例對象賦值給了Person的成員變量，不做其他設置的話，在內存中的表現如下圖(做法不對)：

在調用setter方法的時候，因為Room實例對象多了一個Person對象引用，所以應將Room實例對象的引用計數+1才對，即setter方法應該像下邊一樣，對room進行一次retain操作。

- (void)setRoom:(Room *)room // room = r {// 對房間的引用計數器+1 [room retain];_room = room; }

那么執行完第4行代碼p.room = r;，在內存中的表現為：

繼續執行第5行代碼[r release];，釋放房間，Room實例對象引用計數-1，在內存中的表現如下圖所示：

然后執行第6行代碼[p release];，釋放玩家。這時候因為玩家不在房間里了，房間也沒有用了，所以在釋放玩家的時候，要把房間也釋放掉，也就是在delloc里邊對房間再進行一次release操作。

這樣對房間對象來說，每一次retain/alloc操作都對應一次release操作。

- (void)dealloc {// 人釋放了, 那么房間也需要釋放 [_room release];NSLog(@"%s", __func__);[super dealloc]; }

那么在內存中的表現最終如下圖所示：

最后實例對象的內存就會被系統回收

3. 一個玩家使用一個游戲房間r后，換到另一個游戲房間r2，玩家和房間相關聯的情況

int main(int argc, const char * argv[]) {@autoreleasepool {// 1.創建兩個對象Person *p = [[Person alloc] init]; // 玩家 pRoom *r = [[Room alloc] init]; // 房間 rr.no = 888; // 房間號賦值 // 2.將房間賦值給玩家，表示玩家在使用房間p.room = r; // [p setRoom:r][r release]; // 釋放房間 r// 3. 換房Room *r2 = [[Room alloc] init];r2.no = 444;p.room = r2;[r2 release]; // 釋放房間 r2 [p release]; // 釋放玩家 p }return 0; }

執行下邊幾行代碼

// 1.創建兩個對象Person *p = [[Person alloc] init]; // 玩家 pRoom *r = [[Room alloc] init]; // 房間 rr.no = 888; // 房間號賦值 // 2.將房間賦值給玩家，表示玩家在使用房間p.room = r; // [p setRoom:r][r release]; // 釋放房間 r

之后的內存表現為：

接著執行換房操作而不進行其他操作的話，

// 3. 換房Room *r2 = [[Room alloc] init];r2.no = 444;p.room = r2;

內存的表現為：

最后執行完

[r2 release]; // 釋放房間 r2[p release]; // 釋放玩家 p

內存的表現為：

可以看出房間 r 并沒有被釋放，這是因為在進行換房的時候，并沒有對房間 r 進行釋放。所以應在調用setter方法的時候，對之前的變量進行一次release操作。具體setter方法代碼如下：

- (void)setRoom:(Room *)room // room = r {// 將以前的房間釋放掉 -1 [_room release]; // 對房間的引用計數器+1 [room retain];_room = room;} }

這樣在執行完p.room = r2;之后就會將 房間 r 釋放掉，最終內存表現為：

4. 一個玩家使用一個游戲房間，不再使用游戲房間，將游戲房間釋放掉之后，再次使用該游戲房間的情況

int main(int argc, const char * argv[]) {@autoreleasepool {// 1.創建兩個對象Person *p = [[Person alloc] init];Room *r = [[Room alloc] init];r.no = 888;// 2.將房間賦值給人p.room = r; // [p setRoom:r][r release]; // 釋放房間 r // 3.再次使用房間 rp.room = r;[r release]; // 釋放房間 r [p release]; // 釋放玩家 p }return 0; }

執行下面代碼

// 1.創建兩個對象Person *p = [[Person alloc] init];Room *r = [[Room alloc] init];r.no = 888;// 2.將房間賦值給人p.room = r; // [p setRoom:r][r release]; // 釋放房間 r

之后的內存表現為：

然后再執行p.room = r;，因為setter方法會將之前的Room實例對象先release掉，此時內存表現為：

此時_room、r 已經變成了一個野指針。之后再對野指針 r 發出retain消息，程序就會崩潰。所以我們在進行setter方法的時候，要先判斷一下是否是重復賦值，如果是同一個實例對象，就不需要重復進行release和retain。換句話說，如果我們使用的還是之前的房間，那換房的時候就不需要對這個房間再進行release和retain。則setter方法具體代碼如下：

- (void)setRoom:(Room *)room // room = r {// 只有房間不同才需用release和retainif (_room != room) { // 0ffe1 != 0ffe1// 將以前的房間釋放掉 -1 [_room release];// 對房間的引用計數器+1 [room retain];_room = room;} } 因為retain不僅僅會對引用計數器+1, 而且還會返回當前對象，所以上述代碼可最終簡化成： - (void)setRoom:(Room *)room // room = r {// 只有房間不同才需用release和retainif (_room != room) { // 0ffe1 != 0ffe1// 將以前的房間釋放掉 -1 [_room release]; _room = [room retain];} }

以上就是setter方法的最終形式。

6. @property參數

• 在成員變量前加上@property，系統就會自動幫我們生成基本的setter/getter方法

@property (nonatomic) int val;

• 如果在property后邊加上retain，系統就會自動幫我們生成getter/setter方法內存管理的代碼，但是仍需要我們自己重寫dealloc方法

@property(nonatomic, retain) Room *room;

• 如果在property后邊加上assign，系統就不會幫我們生成set方法內存管理的代碼，僅僅只會生成普通的getter/setter方法，默認什么都不寫就是assign

@property(nonatomic, assign) int val;

7. 自動釋放池

當我們不再使用一個對象的時候應該將其空間釋放，但是有時候我們不知道何時應該將其釋放。為了解決這個問題，Objective-C提供了autorelease方法。

• autorelease是一種支持引用計數的內存管理方式，只要給對象發送一條autorelease消息，會將對象放到一個自動釋放池中，當自動釋放池被銷毀時，會對池子里面的所有對象做一次release操作

  注意,這里只是發送release消息，如果當時的引用計數(reference-counted)依然不為0，則該對象依然不會被釋放。

• autorelease方法會返回對象本身，且調用完autorelease方法后，對象的計數器不變

Person *p = [Person new]; p = [p autorelease]; NSLog(@"count = %lu", [p retainCount]); // 計數還為1

1. 使用autorelease有什么好處呢

• 不用再關心對象釋放的時間
• 不用再關心什么時候調用release

2. autorelease的原理實質上是什么？

autorelease實際上只是把對release的調用延遲了，對于每一個autorelease，系統只是把該對象放入了當前的autorelease pool中,當該pool被釋放時,該pool中的所有對象會被調用release。

3. autorelease的創建方法

使用NSAutoreleasePool來創建

NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; // 創建自動釋放池 [pool release]; // [pool drain]; 銷毀自動釋放池

使用@autoreleasepool創建

@autoreleasepool { //開始代表創建自動釋放池 } //結束代表銷毀自動釋放池

4. autorelease的使用方法

NSAutoreleasePool *autoreleasePool = [[NSAutoreleasePool alloc] init]; Person *p = [[[Person alloc] init] autorelease]; [autoreleasePool drain]; @autoreleasepool { // 創建一個自動釋放池Person *p = [[Person new] autorelease];// 將代碼寫到這里就放入了自動釋放池 } // 銷毀自動釋放池(會給池子中所有對象發送一條release消息)

5. autorelease的注意事項

• 并不是放到自動釋放池代碼中,都會自動加入到自動釋放池

@autoreleasepool {// 因為沒有調用 autorelease 方法,所以對象沒有加入到自動釋放池Person *p = [[Person alloc] init];[p run]; }

• 在自動釋放池的外部發送autorelease 不會被加入到自動釋放池中
  • autorelease是一個方法,只有在自動釋 放池中調用才有效。

@autoreleasepool { } // 沒有與之對應的自動釋放池, 只有在自動釋放池中調用autorelease才會放到釋放池 Person *p = [[[Person alloc] init] autorelease]; [p run];// 正確寫法 @autoreleasepool {Person *p = [[[Person alloc] init] autorelease];}// 正確寫法 Person *p = [[Person alloc] init]; @autoreleasepool {[p autorelease]; }

6. 自動釋放池的嵌套使用

• 自動釋放池是以棧的形式存在
• 由于棧只有一個入口, 所以調用autorelease會將對象放到棧頂的自動釋放池

棧頂就是離調用autorelease方法最近的自動釋放池

@autoreleasepool { // 棧底自動釋放池 @autoreleasepool {@autoreleasepool { // 棧頂自動釋放池Person *p = [[[Person alloc] init] autorelease];}Person *p = [[[Person alloc] init] autorelease];} }

• 自動釋放池中不適宜放占用內存比較大的對象
  • 盡量避免對大內存使用該方法,對于這種延遲釋放機制,還是盡量少用
  • 不要把大量循環操作放到同一個 @autoreleasepool 之間,這樣會造成內存峰值的上升

// 內存暴漲 @autoreleasepool {for (int i = 0; i < 99999; ++i) {Person *p = [[[Person alloc] init] autorelease];} } // 內存不會暴漲 for (int i = 0; i < 99999; ++i) {@autoreleasepool {Person *p = [[[Person alloc] init] autorelease];} }

7. autorelease錯誤用法

• 不要連續調用autorelease

@autoreleasepool {// 錯誤寫法, 過度釋放Person *p = [[[[Person alloc] init] autorelease] autorelease];} 調用autorelease后又調用release(錯誤) @autoreleasepool {Person *p = [[[Person alloc] init] autorelease];[p release]; // 錯誤寫法, 過度釋放 }

?

8. MRC中避免循環retain

定義兩個類Person類和Dog類

• Person類：

#import <Foundation/Foundation.h> @class Dog;@interface Person : NSObject @property(nonatomic, retain)Dog *dog; @end

• Dog類：

#import <Foundation/Foundation.h> @class Person;@interface Dog : NSObject @property(nonatomic, retain)Person *owner; @end

執行以下代碼：

int main(int argc, const char * argv[]) {Person *p = [Person new];Dog *d = [Dog new];p.dog = d; // retaind.owner = p; // retain assign [p release];[d release];return 0; }

就會出現A對象要擁有B對象，而B對應又要擁有A對象，此時會形成循環retain，導致A對象和B對象永遠無法釋放

那么如何解決這個問題呢？

• 不要讓A retain B，B retain A
• 讓其中一方不要做retain操作即可
• 當兩端互相引用時，應該一端用retain，一端用assign

---

4.ARC 自動管理內存(Automatic Reference Counting)

• Automatic Reference Counting，自動引用計數，即ARC，WWDC2011和iOS5所引入的最大的變革和最激動人心的變化。ARC是新的LLVM 3.0編譯器的一項特性，使用ARC，可以說一 舉解決了廣大iOS開發者所憎恨的手動內存管理的麻煩。
• 使用ARC后，系統會檢測出何時需要保持對象，何時需要自動釋放對象，何時需要釋放對象，編譯器會管理好對象的內存，會在何時的地方插入retain, release和autorelease，通過生成正確的代碼去自動釋放或者保持對象。我們完全不用擔心編譯器會出錯

1. ARC的判斷原則

ARC判斷一個對象是否需要釋放不是通過引用計數來進行判斷的，而是通過強指針來進行判斷的。那么什么是強指針?

• 強指針
  • 默認所有對象的指針變量都是強指針
  • 被__strong修飾的指針

Person *p1 = [[Person alloc] init];__strong Person *p2 = [[Person alloc] init];

?

• 弱指針
  • 被__weak修飾的指針

__weak Person *p = [[Person alloc] init];

ARC如何通過強指針來判斷？

• 只要還有一個強指針變量指向對象，對象就會保持在內存中

2. ARC的使用

int main(int argc, const char * argv[]) {// 不用寫release, main函數執行完畢后p會被自動釋放Person *p = [[Person alloc] init];return 0; }

3. ARC的注意點

• 不允許調用對象的 release方法
• 不允許調用 autorelease方法
• 重寫父類的dealloc方法時，不能再調用 [super dealloc];

4. ARC下單對象內存管理

• 局部變量釋放對象隨之被釋放 int main(int argc, const char * argv[]) {@autoreleasepool {Person *p = [[Person alloc] init];} // 執行到這一行局部變量p釋放// 由于沒有強指針指向對象, 所以對象也釋放return 0; }

• 清空指針對象隨之被釋放 int main(int argc, const char * argv[]) {@autoreleasepool {Person *p = [[Person alloc] init];p = nil; // 執行到這一行, 由于沒有強指針指向對象, 所以對象被釋放 }return 0; }

• 默認清空所有指針都是強指針 int main(int argc, const char * argv[]) {@autoreleasepool {// p1和p2都是強指針Person *p1 = [[Person alloc] init];__strong Person *p2 = [[Person alloc] init];}return 0; }

• 弱指針需要明確說明
  • 注意: 千萬不要使用弱指針保存新創建的對象 int main(int argc, const char * argv[]) {@autoreleasepool {// p是弱指針, 對象會被立即釋放__weak Person *p1 = [[Person alloc] init];}return 0; }

5. ARC下多對象內存管理

• ARC和MRC一樣, 想擁有某個對象必須用強指針保存對象, 但是不需要在dealloc方法中release @interface Person : NSObject // MRC寫法 //@property (nonatomic, retain) Dog *dog;// ARC寫法 @property (nonatomic, strong) Dog *dog; @end

6. ARC下@property參數

• strong : 用于OC對象，相當于MRC中的retain
• weak : 用于OC對象，相當于MRC中的assign
• assign : 用于基本數據類型，跟MRC中的assign一樣

6. ARC下循環引用問題

• ARC和MRC一樣，如果A擁有B，B也擁有A，那么必須一方使用弱指針

@interface Person : NSObject @property (nonatomic, strong) Dog *dog; @end@interface Dog : NSObject // 錯誤寫法, 循環引用會導致內存泄露 //@property (nonatomic, strong) Person *owner;// 正確寫法, 當如果保存對象建議使用weak @property (nonatomic, weak) Person *owner; @end

?

作者：行走少年郎
鏈接：https://www.jianshu.com/p/48665652e4e4
來源：簡書

轉載于:https://www.cnblogs.com/jiuyi/p/10404940.html

總結

以上是生活随笔為你收集整理的OC 知识：彻底理解 iOS 内存管理（MRC、ARC）的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。