iOS 開發：徹底理解 iOS 內存管理（MRC、ARC）

本文首發於我的個人博客：『不羈閣』 https://bujige.net
文章鏈接：https://bujige.net/blog/iOS-Memory-management.html

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對象還會留在內存中,因爲它是計數器依然是1
    return 0;
}

 

圖片1.png

---

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 {
        // 只要創建一個對象默認引用計數器的值就是1
        Person *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並不代表銷燬\回收對象, 僅僅是計數器-1
        NSLog(@"retainCount = %lu", [p retainCount]); // 1

        [p release]; // 0
        NSLog(@"--------");
    }
//    [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

 

圖片2.png

 

下面來定義兩個類 玩家類：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];    // 玩家 p
        Room *r = [[Room alloc] init];        // 房間 r
        r.no = 888;    // 房間號賦值

        [r release];    // 釋放房間      
        [p release];   // 釋放玩家
    }
    return 0;
}

上述代碼執行完前3行

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

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

 

圖片3.png

可見，Room實例對象和Person實例對象之間沒有相互聯繫，所以各自釋放不會報錯。執行完4、5行代碼

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

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

 

圖片4.png

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

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

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

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

 

圖片3.png

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

 

圖片5.png

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

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

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

 

圖片6.png

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

 

圖片5.png

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

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

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

    [super dealloc];
}

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

 

圖片7.png

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

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

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // 1.創建兩個對象
        Person *p = [[Person alloc] init];    // 玩家 p
        Room *r = [[Room alloc] init];        // 房間 r
        r.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];    // 玩家 p
        Room *r = [[Room alloc] init];        // 房間 r
        r.no = 888;    // 房間號賦值          

        // 2.將房間賦值給玩家，表示玩家在使用房間
        p.room = r; // [p setRoom:r]
        [r release];    // 釋放房間 r

之後的內存表現爲：

 

圖片8.png

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

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

內存的表現爲：

 

圖片9.png

最後執行完

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

內存的表現爲：

 

圖片10.png

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

- (void)setRoom:(Room *)room // room = r
{
        // 將以前的房間釋放掉 -1
        [_room release];     

        // 對房間的引用計數器+1
        [room retain];

        _room = room;
    }
}

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

 

圖片11.png

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.再次使用房間 r
        p.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  

之後的內存表現爲：

 

圖片12.png

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

 

圖片13.png

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

- (void)setRoom:(Room *)room // room = r
{
    // 只有房間不同才需用release和retain
    if (_room != room) {    // 0ffe1 != 0ffe1
        // 將以前的房間釋放掉 -1
        [_room release];

        // 對房間的引用計數器+1
        [room retain];

        _room = room;
    }
}

因爲retain不僅僅會對引用計數器+1, 而且還會返回當前對象，所以上述代碼可最終簡化成：

- (void)setRoom:(Room *)room // room = r
{
    // 只有房間不同才需用release和retain
    if (_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, retain) 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的創建方法

1. 使用NSAutoreleasePool來創建

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

1. 使用@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; // retain
    d.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