OC 知識：徹底理解 iOS 記憶體管理（MRC、ARC）

来源:https://www.cnblogs.com/jiuyi/archive/2019/02/20/10404940.html
-Advertisement-
Play Games

1. 什麼是記憶體管理 程式在運行的過程中通常通過以下行為，來增加程式的的記憶體占用 創建一個OC對象 定義一個變數 調用一個函數或者方法 而一個移動設備的記憶體是有限的，每個軟體所能占用的記憶體也是有限的 當程式所占用的記憶體較多時，系統就會發出記憶體警告，這時就得回收一些不需要再使用的記憶體空間。比如回收一些 ...


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

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
 

下麵來定義兩個類 玩家類：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;    // 房間號賦值

之後在記憶體中的表現如下圖所示：



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

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

最後各自實例對象的記憶體就會被系統回收

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行的時候和之前在記憶體中的表現一樣，如圖

當執行完第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];    // 玩家 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

之後的記憶體表現為：

 

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

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

之後的記憶體表現為：

 

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

 

此時_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, 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的創建方法

  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

 

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


您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • xtrabackup備份mysql資料庫方法
    1.安裝 xtrabackup 工具包 下載percona yum源 https://www.percona.com/redir/downloads/percona-release/redhat/percona-release-0.1-4.noarch.rpm 通過 yum 方式安裝 percona ...
  • 資料庫分片（Database Sharding)詳解
    本文由雲+社區發表 作者：騰訊雲資料庫 Introduction 導言 任何看到顯著增長的應用程式或網站，最終都需要進行擴展，以適應流量的增加。以確保數據安全性和完整性的方式進行擴展，對於數據驅動的應用程式和網站來說十分重要。人們可能很難預測某個網站或應用程式的流行程度，也很難預測這種流行程度會持續 ...
  • 01. Overview Redis 關於Redis
    LOGO The tags of features: 開源，記憶體數據存儲，被用作為資料庫，cache and message 中間人/中間件 一個實例：單進程（無子進程），單線程，I/O多路復用( multiplexing and non-blocking I/O)處理客戶端的TCP連接。 支持的數 ...
  • OC 知識：Foundation 框架及相關類詳盡總結
    本文用來介紹Foundation框架的相關知識，以及Foundation框架所提供類的相關知識總結。 1. 框架介紹 框架是由很多類、方法、函數和文檔按照一定的邏輯組織起來的集合，以使開發程式變得更加容易。在OS X系統下有100多個框架，這些框架可以用來開發應用程式。 2. Foundation框 ...
  • Flutter 即學即用系列博客——05 StatelessWidget vs StatefulWidget
    Flutter 即學即用系列博客第五彈來了。 自定義 Widget 讓你對 UI 瞭解更加深入。 還有 dart 語法糖
  • 糧草先行——Android摺疊屏開發技術點（二）
    繼該系列的第一篇和番外篇之後，今天我們來聊一聊多視窗開發的註意事項。實際上，與其說“多視窗開發”，不如說讓我們的APP 適應多視窗模式 。 可能有朋友會問，為什麼要提到多視窗模式呢？ 這是因為： 1. 摺疊屏在展開後的屏幕會變大，而變大帶來的變化就是多視窗運行； 2. 多視窗模式在很早之前就已經被G ...
  • 安卓開發中實現自動點擊功能、獲取網路信息’-博客新人初來乍到，歡迎大佬多多指教。
    本人做安卓開發三個月，不是本專業的（興趣轉行），是一枚萌新，目前公司的項目是一個游戲的腳本，但畢竟一個項目所用到的知識是有限的，所以決定開通博客，堅持每天學習（目前也沒發現好的學習資源，知識比較老）並分享，這幾天將分享公司項目用到的技術同時還有自己學習的東西，請多多指教！！！ github後期同步更 ...
  • C#-Xamarin的Android項目開發(二)——控制項應用
    相信我，這不是一篇吐槽文章。。。。 基礎控制項 Android的控制項和控制項樣式非常特別，它是一種內聯特別高的設計模式，換句話說，它是非常爛的設計。。。。 但在這種特別的關係里還是有一定的規律的，下麵我們一起來看看控制項的使用方式。 首先我們定義一個ImageButton，如下： 如上代碼所示，我們定義了 ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類