您现在的位置: IOS教程網 >> IOS系統 >  >> iOS 程式開發 >> iOS 開發綜合

自動引用計數(ARC)深入解析:從引用計數到所有權修飾符

編輯:iOS 開發綜合

本文整理自《Objective-C 高級編程:iOS 與 OS X 多執行緒和記憶體管理》,重點放在 ARC 的設計思路、四種所有權修飾符,以及編譯器背後實際做了哪些事。

一、什麼是自動引用計數

ARC(Automatic Reference Counting)指的是在記憶體管理中「自動為引用計數」的技術。蘋果官方的說明是:

在 Objective-C 中採用 Automatic Reference Counting 機制,讓編譯器來進行記憶體管理。在新一代 Apple LLVM 編譯器中將 ARC 設為有效狀態後,就無需再鍵入 retain 或 release 程式碼,這在降低程式崩潰、記憶體洩漏風險的同時,也大幅減少了開發工作量。編譯器能完整掌握目標物件,並立刻釋放那些不再被使用的物件,讓程式更具可預防性、運行更流暢,速度也隨之提升。

使用 ARC 的基本條件:

  • Xcode 4.2 以上版本
  • LLVM 編譯器 3.0 以上版本
  • 在編譯器選項中把 ARC 設為有效

二、記憶體管理與引用計數

Objective-C 提供三種記憶體管理方式:

  1. MRR(Manual Retain-Release):手動管理引用計數
  2. ARC(Automatic Reference Counting):自動引用計數
  3. GC(Garbage Collection):垃圾回收

1. 基本原理

ObjC 以「引用計數」進行管理,可以拆成四步理解:

  1. 每個物件都有一個關聯的整數,稱為引用計數器。
  2. 程式碼需要使用該物件時,將計數加一。
  3. 程式碼結束使用該物件時,將計數減一。
  4. 計數變為 0,代表沒有任何程式碼在使用它,此時物件被釋放。

對應的訊息發送方式:

  1. 物件透過 alloc、new、copy 等方法建立時,引用計數初始值為 1。
  2. 送出 retain 訊息,計數加一。
  3. 送出 release 訊息,計數減一。
  4. 計數歸零時,ObjC 送出 dealloc 訊息銷毀物件。

2. 思考方式:所有權

整套規則其實只有四句話:

  • 自己產生的物件,自己持有
  • 非自己產生的物件,自己也能持有
  • 不再需要自己持有的物件時要釋放
  • 非自己持有的物件,無權釋放

物件操作與 Objective-C 方法的對應關係如下:

  • 產生並持有物件:alloc / new / copy / mutableCopy
  • 持有物件:retain
  • 釋放物件:release
  • 廢棄物件:dealloc

(1)自己產生的物件,自己持有

id obj = [[NSObject alloc] init];
id obj = [NSObject new];   // 作用同上

copy 依據 NSCoping 的約定,由類別各自實作的 copyWithZone: 產生並持有副本;mutableCopy 則依據 NSMutableCopying,由 mutableCopyWithZone: 產生副本。兩者的差別在於 copy 產生的是不可變更的物件,mutableCopy 產生的是可變更物件。

(2)非自己產生的物件,自己也能持有

// 取得非自己產生並持有的物件
id obj = [NSMutableArray array];
// 此時物件存在,但自己不持有
[obj retain];
// 現在自己持有它

(3)不再需要時釋放

id obj = [[NSMutableArray alloc] init];  // 自己產生並持有
[obj release];                            // 釋放

(4)非自己持有的物件不能釋放

id obj = [NSMutableArray array];  // 物件存在,但自己不持有
[obj release];                    // 這會導致程式崩潰

3. alloc / retain / release / dealloc 的底層實作

GNUstep 是 Cocoa 框架的互換實作,可以直接對照它的原始碼來理解 Apple 的行為。alloc 最終會走到 allocWithZone::

+ (id)alloc {
    return [self allocWithZone: NSDefaultMallocZone()];
}

+ (id)allocWithZone:(NSZone *)z {
    return NSAllocateObject(self, 0, z);
}

NSAllocateObject 會呼叫 NSZoneMalloc 配置物件所需的記憶體,接著把整塊記憶體清零,最後回傳可作為物件使用的指標。

補充:NSZone 是為了避免記憶體碎片而引入的結構,它對記憶體配置區域本身做多重化管理,可依物件的目的與大小分配合適的區域,从而提升整體記憶體管理效率。

alloc 會透過 struct obj_layout 中的 retained 整數保存引用計數,並寫入物件記憶體的標頭;整塊記憶體清零後再回傳:

struct obj_layout {
    char padding[__BIGGEST_ALIGNMENT__ - ((UNP % __BIGGEST_ALIGNMENT__) ? (UNP % __BIGGEST_ALIGNMENT__) : __BIGGEST_ALIGNMENT__)];
    NSUInteger retained;
};
typedef struct obj_layout *obj;

4. 自動釋放池(autorelease)

autorelease 的意思就是「自動釋放」:當你對一個物件送出 autorelease 訊息,它會在未來某個時間點收到 release,而在那段時間內,物件仍然可以使用。

原理:物件收到 autorelease 時,會被加入目前正在作用的自動釋放池;當釋放池被銷毀時,池中所有物件都會收到 release。

用法:

NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
// 這裡寫程式碼
[pool release];

也可以使用更現代的語法:

@autoreleasepool {
    // 這裡寫程式碼
}

使用步驟是:產生並持有 NSAutoreleasePool → 對已配置物件呼叫 autorelease → 廢棄 NSAutoreleasePool。

NSAutoreleasePool 的生命週期等同於 C 語言變數的作用域。凡是呼叫過 autorelease 的物件,都會在 pool 被廢棄時收到 release。在 Cocoa 框架中,主執行緒的 NSRunLoop 或其他可運行點會負責產生、持有與廢棄 pool。

要注意的是:只要你持續產生 autorelease 物件卻不廢棄 pool,這些物件就無法被釋放,記憶體占用會不斷累積。因此在迴圈中大量產生臨時物件時,應該在每一輪內部建立並釋放 pool:

for (int i = 0; i < count; ++i) {
    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
    // 處理本輪工作
    [pool drain];
}

三、ARC 的規則

1. 編譯選項

  • 讓 ARC 有效:指定編譯器旗標 -fobjc-arc
  • 讓 ARC 無效:指定編譯器旗標 -fno-objc-arc(常用於必須保留 MRC 寫法的第三方老程式碼)

2. 所有權修飾符

ARC 有效時,id 型別與各種物件型別(例如 NSObject *)在宣告上必須附加「所有權修飾符」,一共有四種:

  • __strong
  • __weak
  • __unsafe_unretained
  • __autoreleasing

(1)__strong

__strong 是 id 型別與物件型別的預設修飾符,也就是說即使你不寫,編譯器也會視同已經附加:

// 以下兩行等價
id obj = [[NSObject alloc] init];
id __strong obj = [[NSObject alloc] init];

附有 __strong 的變數之間可以相互賦值,而且不僅在變數作用域內,在賦值這件事上也能正確管理物件的所有者。

(2)__weak

單純依賴引用計數時,會出現「循環引用」的問題:A 強引用 B、B 又強引用 A,兩者的計數永遠不會歸零。

__weak 與 strong 相反,提供的是弱引用,也就是「不持有物件」的參照。這樣一來,物件在建立之後就能立刻被釋放,不會因為被弱引用而延長生命週期:

{
    id __strong obj1 = [[NSObject alloc] init];
    id __weak obj2 = obj1;
}

__weak 還有一個實務上非常重要的優點:當被參照的物件遭廢棄時,該弱引用會自動被設為 nil(空弱引用),因此不會出現指向已釋放記憶體的垂掛指標。

(3)__unsafe_unretained

這是不安全的修飾符,附有它的變數不屬於編譯器的記憶體管理對象。它和 __weak 一樣不持有物件,因此物件會立即被釋放;但差別在於變數不會被自動設為 nil,若物件已被釋放,存取它就會造成崩潰。

(4)__autoreleasing

ARC 有效時,autorelease 方法與 NSAutoreleasePool 都不能直接使用,必須改用 @autoreleasepool 區塊,並以「賦值給附加 __autoreleasing 的變數」來取代呼叫 autorelease:

@autoreleasepool {
    id __autoreleasing obj = [[NSObject alloc] init];
}

典型流程如下:

@autoreleasepool {
    // 取得非自己產生並持有的物件
    id __strong obj = [NSMutableArray array];
    // 因為 obj 是強引用,所以自己持有該物件;
    // 同時編譯器會依方法名判斷,自動把它註冊到 autoreleasepool
}
// obj 超出作用域、強引用失效,持有的物件被自動釋放;
// 隨著 @autoreleasepool 區塊結束,註冊其中的所有物件也一併被釋放。

另外,透過 __weak 變數存取物件時,必定會經由註冊到 autoreleasepool 的那份參照。這是因為 weak 只持有弱引用,存取過程中物件隨時可能被廢棄;先把要存取的物件放進 pool,就能確保在 pool 區塊結束之前它一定存在。

id 指標或物件指標若沒有明確標示,會被附加 __autoreleasing:

NSObject **obj;    // 等同於 NSObject * __autoreleasing *obj;
NSError **error;   // 等同於 NSError * __autoreleasing *error;

把指標位址賦值給另一個指標時,所有權修飾符必須一致,否則編譯器會出現警告:

// 需要加上 __strong
NSError *error = nil;
NSError *__strong *pError = &error;

// 或加上 __weak
NSError __weak *error = nil;
NSError *__weak *pError = &error;

// 以下寫法也是正確的,編譯器實際上會改寫成後面的形式
NSError __strong *error = nil;
NSError **pError = &error;

// 改寫後
NSError __strong *error = nil;
NSError *__autoreleasing *tem = error;
NSError **pError = &tem;

3. ARC 之下必須遵守的規則

  • 不能使用 retain / release / retainCount / autorelease
  • 不能使用 NSAllocateObject / NSDeallocateObject
  • 必須遵守記憶體管理的方法命名規則(例如 alloc、new、copy、mutableCopy 開頭的方法,其回傳值的所有權語意由編譯器依名稱判斷)
  • 不得顯式呼叫 dealloc
  • 使用 @autoreleasepool 區塊取代 NSAutoreleasePool
  • 不能使用區域(NSZone)
  • 物件型變數不能作為 C 語言結構體(struct / union)的成員
  • id 與 void * 之間的顯式轉換必須使用橋接轉換

id 型或物件型變數與 void * 互轉時,若只是單純賦值,可用 __bridge:

id obj = ...;
void *p = (__bridge void *)obj;
id o = (__bridge id)p;

但要注意,經 __bridge 轉成 void * 之後,安全性與 __unsafe_unretained 相當甚至更低。如果沒有留意所有權的歸屬,一樣會因為垂掛指標而崩潰。

__bridge 有兩種類型:__bridge_retained 與 __bridge_transfer,語意上分別對應 retain 與 release。

4. ARC 下的屬性宣告

ARC 有效時,各屬性關鍵字與所有權修飾符的對應如下:

  • assign → __unsafe_unretained
  • copy → __strong(但賦值的是複製後的物件)
  • retain → __strong
  • strong → __strong
  • unsafe_unretained → __unsafe_unretained
  • weak → __weak

四、ARC 的底層實現

1. __strong 的最佳化

這段最直覺的寫法:

id __strong obj = [NSMutableArray array];

在編譯器眼中會被展開成類似下面的形式:

id obj = objc_msgSend(NSMutableArray, @selector(array));
objc_retainAutoreleasedReturnValue(obj);
objc_release(obj);

關鍵在 objc_retainAutoreleasedReturnValue,它與另一個函數 objc_autoreleaseReturnValue 成對出現。看看 array 這個工廠方法本身被轉換成什麼:

+ (id)array {
    return [[NSMutableArray alloc] init];
}

// 轉換後
id obj = objc_msgSend(NSMutableArray, @selector(alloc));
objc_msgSend(obj, @selector(init));
return objc_autoreleaseReturnValue(obj);

objc_autoreleaseReturnValue 表面上是要把物件註冊到 autoreleasepool,但它會先檢查呼叫方的執行命令列表:如果呼叫方在呼叫之後緊接著就執行 objc_retainAutoreleasedReturnValue,那麼這個物件不會被放進 pool,而是直接交到呼叫方手上。這正是 ARC 在「既維持所有權語意、又避免多餘的 retain/release 與 pool 註冊開銷」之間所做的取捨。

2. __weak 的實現

__weak 有兩個核心行為:

  1. 若附有 __weak 的變數所參照的物件被廢棄,則該變數會被賦值為 nil。
  2. 透過附有 __weak 的變數存取時,實際存取的是註冊到 autoreleasepool 中的物件。
id __weak obj1 = obj;

// 概念上展開為
id obj1;
objc_initWeak(&obj1, obj);
objc_destroyWeak(&obj1);

更貼近實作的寫法則是透過 weak 表來登記:

id obj1;
obj1 = 0;
objc_storeWeak(&obj1, obj);   // 註冊
objc_storeWeak(&obj1, 0);     // 從 weak 表移除

說明一下:第一次呼叫 objc_storeWeak 時,會把第二個參數(即賦值物件)的位址當作鍵值,將第一個參數這個附有 __weak 的變數位址註冊到 weak 表中;第二次呼叫時第二個參數為 0,代表把該變數的位址從 weak 表中刪除。當物件本身被釋放時,Runtime 會依 weak 表把對應的所有變數設為 nil——這就是「弱引用自動歸零」的實作方式。

  1. 上一篇文章:
  2. 下一篇文章:
蘋果刷機越獄教程| IOS教程問題解答| IOS技巧綜合| IOS7技巧| IOS8教程
Copyright © IOS教程網 All Rights Reserved