OC知識--徹底理解記憶體管理(MRC、ARC)

阿新 • • 發佈：2019-01-05

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的建立方法

使用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; // 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

作者：行走的少年郎
連結：https://www.jianshu.com/p/48665652e4e4
來源：簡書
著作權歸作者所有。商業轉載請聯絡作者獲得授權，非商業轉載請註明出處。