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

iOS 開發 ARC 內存管理技術要點全解析

編輯:iOS 開發基礎

本文來自我個人的 ARC 學習筆記,旨在以簡明扼要的方式總結 iOS 開發中 ARC(Automatic Reference Counting,自動引用計數)內存管理技術的要點,因此不會涉及全部細節。這篇文章不是標準的 ARC 使用教程,並假定讀者已對 ARC 有一定了解和使用經驗。詳細信息請參見蘋果官方文檔與網上其他教程。

本文主要内容:

  • ARC 的本質

  • ARC 的開啟與關閉

  • ARC 的修飾符

  • ARC 與 Block

  • ARC 與 Toll-Free Bridging

ARC 的本質


ARC 是編譯器(時)特性,而不是運行時特性,更不是垃圾回收器(GC)。

Automatic Reference Counting (ARC) is a compiler-level feature that simplifies the process of managing object lifetimes (memory management) in Cocoa applications.

ARC 只是相對於 MRC(Manual Reference Counting,或稱非 ARC,下文一直用 MRC 指代非 ARC 管理方式)的一次改進,本質上和之前沒有區別。具體信息可參考 ARC 編譯器官方文檔。

ARC 的開啟與關閉


不同於 Xcode 4 可在創建工程時選擇關閉 ARC,Xcode 5 創建的工程默認開啟 ARC,沒有關閉選項。

若需對特定文件開啟或關閉 ARC,可在工程選項中選擇 Targets → Compile Phases → Compile Sources,找到對應文件添加 flag:

  • 打開 ARC:-fobjc-arc

  • 關閉 ARC:-fno-objc-arc

如圖:

ARC 的修飾符


ARC 主要提供 4 種修飾符:__strong、__weak、__autoreleasing、__unsafe_unretained。

__strong

表示強引用,對應定義 property 時的「strong」。所有對象只有在沒有任何強引用指向時才會被釋放。注意:聲明引用時若不加修飾符,默認就是強引用。要釋放強引用指向的對象,需將強引用置 nil。

__weak

表示弱引用,對應定義 property 時的「weak」。弱引用不影響對象釋放——只要對象沒有任何強引用指向,即使有 100 個弱引用指向也沒用,對象依然會被釋放。好在對象被釋放時,指向它的弱引用會自動置 nil,這個技術叫 zeroing weak pointer,能有效防止無效指針、野指針產生。__weak 一般用於 delegate 關係中防止循環引用,或修飾指向 Interface Builder 生成的 UI 控件。

__autoreleasing

表示在 autorelease pool 中自動釋放對象引用,和 MRC 時代 autorelease 用法相同。定義 property 時不能用這個修飾符,任何對象的 property 都不應是 autorelease 型。

一個常見誤解是「ARC 中沒有 autorelease」,因為「自動釋放」看起來有點多餘。這誤解可能源自把 ARC 的「自動」和 autorelease 的「自動」混淆。其實只要看看每個 iOS App 的 main.m 就知道,autorelease 不僅好好存在,還變得更 fashion 了:不需手工創建,也不需顯式調用 [drain] 釋放內存池。

以下兩行代碼意義相同:

NSString *str = [[[NSString alloc] initWithFormat:@"hehe"] autorelease];  // MRC
NSString *__autoreleasing str = [[NSString alloc] initWithFormat:@"hehe"];  // ARC

__autoreleasing 在 ARC 中主要用於參數傳遞返回值(out-parameters)和引用傳遞參數(pass-by-reference)的情況。

__autoreleasing is used to denote arguments that are passed by reference (id *) and are autoreleased on return.

比如常用的 NSError:

NSError *__autoreleasing error;
if (![data writeToFile:filename options:NSDataWritingAtomic error:&error]) {
    NSLog(@"%@", error);
}

(writeToFile 方法中 error 參數類型為 (NSError *__autoreleasing *))

注意,若你把 error 定義為 strong 型,編譯器會幫你隱式地做如下事情,保證最終傳入函數的參數仍是 __autoreleasing 型引用:

NSError *error;
NSError *__autoreleasing tempError = error; // 編譯器添加
if (![data writeToFile:filename options:NSDataWritingAtomic error:&tempError]) {
    error = tempError; // 編譯器添加
    NSLog(@"Error: %@", error);
}

所以為提高效率、避免這種情況,一般建議老老實實把 error 聲明為 __autoreleasing 型:

NSError *__autoreleasing error;

加上 __autoreleasing 後,相當於在 MRC 中對返回值 error 做了:

*error = [[[NSError alloc] init] autorelease];

*error 指向的對象創建後被放入 autoreleasing pool,等待使用結束後自動釋放,函數外的使用者無需關心它的釋放。

另外,在 ARC 中,所有這種「指針的指針」(NSError **)函數參數若不加修飾符,編譯器會默認認定為 __autoreleasing 型。比如下面兩段代碼等價:

- (NSString *)doSomething:(NSNumber **)value {
    // do something
}
- (NSString *)doSomething:(NSNumber * __autoreleasing *)value {
    // do something
}

除非你顯式給 value 聲明 __strong,否則默認就是 __autoreleasing。

最後一點,某些類的方法會隱式使用自己的 autorelease pool,此時使用 __autoreleasing 要特別小心。比如 NSDictionary 的 [enumerateKeysAndObjectsUsingBlock] 方法:

- (void)loopThroughDictionary:(NSDictionary *)dict error:(NSError **)error {
    [dict enumerateKeysAndObjectsUsingBlock:^(id key, id obj, BOOL *stop){
        // do stuff
        if (there is some error && error != nil) {
            *error = [NSError errorWithDomain:@"MyError" code:1 userInfo:nil];
        }
    }];
}

它會隱式創建一個 autorelease pool,上述代碼實際類似於:

- (void)loopThroughDictionary:(NSDictionary *)dict error:(NSError **)error {
    [dict enumerateKeysAndObjectsUsingBlock:^(id key, id obj, BOOL *stop){
        @autoreleasepool // 被隱式創建
        {
            if (there is some error && error != nil) {
                *error = [NSError errorWithDomain:@"MyError" code:1 userInfo:nil];
            }
        }
    }];
    // *error 在這裡已被 dict 枚舉時創建的 autorelease pool 釋放掉了
}

為能正常使用 *error,我們需要一個 strong 型的臨時引用,在 dict 的枚舉 Block 中使用它,保證引用指向的對象不會在出了枚舉 Block 後被釋放,正確方式如下:

- (void)loopThroughDictionary:(NSDictionary *)dict error:(NSError **)error {
    __block NSError* tempError; // 加 __block 保證可以在 Block 內被修改
    [dict enumerateKeysAndObjectsUsingBlock:^(id key, id obj, BOOL *stop) {
        if (there is some error) {
            *tempError = [NSError errorWithDomain:@"MyError" code:1 userInfo:nil];
        }
    }]
    if (error != nil) {
        *error = tempError;
    }
}

__unsafe_unretained

ARC 在 iOS 5 引入,這個修飾符主要是為了兼容 iOS 4 及更低版本設備,因為這些版本沒有 weak pointer system(即上面講 weak 時提到的、能在弱引用指向對象被釋放後自動置 nil 的系統)。定義 property 時它對應「unsafe_unretained」,可理解為 MRC 時代的 assign:純粹只是把引用指向對象,沒有任何額外操作,指向對象被釋放時依然原原本本指向原來(已釋放)的記憶體區域,所以非常不安全。現在完全可以忽略它,因為 iOS 4 早已退出歷史舞台。

使用修飾符的正確姿勢

這可能是很多人都不知道、卻特別要注意的問題。蘋果文檔明確寫道:

You should decorate variables correctly. When using qualifiers in an object variable declaration, the correct format is:

ClassName * qualifier variableName;

按此說明,定義一個 weak 型的 NSString 引用應該寫成:

NSString * __weak str = @"hehe";  // 正確!

而不應該是:

__weak NSString *str = @"hehe";   // 錯誤!

相信很多人都和我一樣,從開始用 ARC 就一直用上面那種錯誤寫法。那既然文檔說是錯誤的,為啥編譯器不報錯?文檔又解釋道:

Other variants are technically incorrect but are "forgiven" by the compiler. To understand the issue, see https://cdecl.org/.

看來是蘋果考慮到很多人會用錯,貼心地幫我們忽略並處理掉了這個錯誤。雖不報錯,但我們還是按正確方式使用為好——哪天編譯器不支持錯誤寫法,就要鬱悶了。

棧中指針默認值為 nil

無論被 strong、weak 還是 autoreleasing 修飾,聲明在棧中的指針默認值都會是 nil,這類指針不用再初始化置 nil。好習慣固然重要,但這個特性更降低了「野指針」出現的可能性。在 ARC 中,以下代碼會輸出 null 而不是 crash:

- (void)myMethod {
    NSString *name;
    NSLog(@"name: %@", name);
}

ARC 與 Block


在 MRC 時代,Block 會隱式地對進入其作用域內的對象(被 Block 捕獲的指針指向的對象)加 retain,以確保 Block 用到該對象時能正確訪問。這件事在下面代碼展示的情況中要格外小心。

MyViewController *myController = [[MyViewController alloc] init…]; // 隱式調用 [myController retain],造成循環引用
myController.completionHandler =  ^(NSInteger result) {
    [myController dismissViewControllerAnimated:YES completion:nil];
};
[self presentViewController:myController animated:YES completion:^{
    [myController release]; // MRC 常規寫法,並不能解決循環引用
}];

這段代碼中,myController 的 completionHandler 調用了 myController 的方法,此時 completionHandler 會對 myController 做 retain;而 myController 對 completionHandler 也至少有一個 retain(一般講是 copy),於是出現內存管理中最糟的情況:循環引用。簡單說就是 myController retain 了 completionHandler,completionHandler 也 retain 了 myController,導致兩者最終都不能被釋放。我們在 delegate 關係中對 delegate 用 weak 就是為了避免這種問題。

好在編譯器會及時給我們警告:

這種情況一般給要進入 Block 的指針加一個 __block 修飾符。這個 __block 在 MRC 時代有兩個作用:

  • 說明變量可改

  • 說明指針指向的對象不做這個隱式 retain

一個變量若不加 __block,不能在 Block 裡修改,但有個例外:static 變量和全局變量不需加 __block 就能在 Block 中修改。

用這種方法修改代碼,解決了循環引用:

MyViewController * __block myController = [[MyViewController alloc] init…]; // ...
myController.completionHandler =  ^(NSInteger result) {
    [myController dismissViewControllerAnimated:YES completion:nil];
};
// 之後正常 release 或 retain

在 ARC 引入後,沒有了 retain 和 release,情況也變了:任何情況下 __block 的作用只有第一條——說明變量可改。即使加上 __block,被 Block 捕獲的強引用依然是強引用。這樣在 ARC 下若還按 MRC 寫法,completionHandler 對 myController 有強引用、myController 對 completionHandler 也有強引用,這依然是循環引用,沒解決問題。

於是還需再改。簡單情況可以這樣寫:

__block MyViewController * myController = [[MyViewController alloc] init…]; // ...
myController.completionHandler =  ^(NSInteger result) {
    [myController dismissViewControllerAnimated:YES completion:nil];
    myController = nil;  // 保證 block 結束時 myController 強引用解除
};

在 completionHandler 後把 myController 置 nil,保證解除 completionHandler 對 myController 的強引用,不過也同時解除了 myController 對自身的強引用。這方法過於簡單粗暴,大多數情況我們有更好的方法——使用 weak。

為保證 completionHandler 這個 Block 對 myController 沒有強引用,可定義一個臨時弱引用 weakMyViewController 指向原對象並傳入 Block,如此 Block 對 myController 持有的就是弱引用:

MyViewController *myController = [[MyViewController alloc] init…]; // ...
MyViewController * __weak weakMyViewController = myController;
myController.completionHandler =  ^(NSInteger result) {
    [weakMyViewController dismissViewControllerAnimated:YES completion:nil];
};

循環引用解決了,但不幸引入新問題:由於傳入的是弱引用,若 myController 對象在 completionHandler 被調用前釋放,Block 就不能正常運作。單線程環境這種問題出現概率不大,但多線程環境就很不好說,所以需繼續完善。

為保證 Block 內能訪問到正確的 myController,我們在 Block 內新定義一個強引用 strongMyController 指向 weakMyController,多一個強引用就能保證對象不會在 completionHandler 被調用前釋放:

MyViewController *myController = [[MyViewController alloc] init…]; // ...
MyViewController * __weak weakMyController = myController;
myController.completionHandler =  ^(NSInteger result) {
    MyViewController *strongMyController = weakMyController;
    if (strongMyController) {
        [strongMyController dismissViewControllerAnimated:YES completion:nil];
    } else {
        // Probably nothing...
    }
};

至此,一個完善的解決方案就完成了。

官方文檔到此結束,但可能很多朋友會有疑問:不是說不希望 Block 對原 myController 增加強引用嗎,這裡為啥堂而皇之在 Block 內新定義一個強引用,它不會造成循環引用嗎?理解關鍵在於區分「被 Block 捕獲的引用」和「在 Block 內定義的引用」。這需要了解 Block 的實現原理(可參考唐巧等人的文章)。

這裡用一個簡單程序舉例:

#include < stdio.h>
int main() {
    int b = 10;
    int *a = &b;
    void (^blockFunc)() = ^(){
        int *c = a;
    };
    blockFunc();
    return 1;
}

程序中,同為 int 型指針,a 是被 Block 捕獲的變量,c 是在 Block 內定義的變量。用 clang -rewrite-objc 處理後可看到:

Block 的結構:

struct __main_block_impl_0 {
    struct __block_impl impl;
    struct __main_block_desc_0* Desc;
    int *a; // 被捕獲的引用 a 出現在了 block 的結構體裡面
    __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int *_a, int flags=0) : a(_a) {
        impl.isa = &_NSConcreteStackBlock;
        impl.Flags = flags;
        impl.FuncPtr = fp;
        Desc = desc;
    }
};

實際執行的函數:

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
    int *a = __cself->a; // bound by copy
    int *c = a; // 在 block 中聲明的引用 c 存在於函數棧上
}

可以清楚看到 a 和 c 存在位置完全不同:若 Block 存在於堆上(ARC 下 Block 默認在堆上),a 作為 Block 結構體的成員也自然在堆上;而 c 無論如何永遠位於 Block 實際執行代碼的函數棧內。這導致兩個變量生命週期完全不同:c 在函數運行完畢即被釋放,而 a 只有在 Block 被從堆上釋放時才釋放。

回到 MyViewController 例子,若直接讓 Block 捕獲 myController 引用,這個引用會被複製後(引用類型也會被複製)作為 Block 的成員變量存在於堆空間,也就是為 Block 增加了一個指向 myController 對象的強引用,這就是循環引用的本質原因。反觀傳入弱引用 weakMyController,Block 捕獲的是弱引用,不會增加強引用。而 Block 內聲明的強引用 strongMyController 雖是強引用,卻存在於函數棧中,函數執行期間它一直存在、對象也一直存在,但函數執行完畢它即被銷毀,對 myController 的強引用也隨之解除——此時 Block 對 myController 就不存在強引用關係了。

綜上所述,在 ARC 下(MRC 下略有不同),Block 捕獲的引用和 Block 內聲明的引用無論存在空間與生命週期都截然不同,也正是這種不同,造成了我們對它們使用方式的區別。

最後提一點:在 ARC 中,對 Block 捕獲對象的內存管理已簡化很多,由於沒有 retain 和 release,實際只需考慮循環引用。比如下面這種是沒有內存洩露問題的:

TestObject *aObject = [[TestObject alloc] init];
aObject.name = @"hehe";
self.aBlock = ^(){
    NSLog(@"aObject's name = %@", aObject.name);
};

我們上面提到的方案只是針對 Block 產生循環引用的問題,不是說所有 Block 捕獲引用都要這麼處理,一定要注意!

ARC 與 Toll-Free Bridging


There are a number of data types in the Core Foundation framework and the Foundation framework that can be used interchangeably. This capability, called toll-free bridging, means that you can use the same data type as the parameter to a Core Foundation function call or as the receiver of an Objective-C message.

Toll-Free Bridging 保證了程序中可以方便和諧地使用 Core Foundation 類型對象和 Objective-C 類型對象。在 MRC 時代,兩類對象都是相同的 release 和 retain 規則,使用較簡單;但自 ARC 加入後,Objective-C 類型對象的內存管理規則變了,而 Core Foundation 依然是舊機制(不支持 ARC)。

這時就必須考慮:做 Core Foundation 與 Objective-C 類型轉換時,用哪一種規則管理對象內存。顯然,對同一個對象不能同時用兩種規則管理,所以必須確定哪些對象用 Objective-C(ARC)規則、哪些用 Core Foundation(MRC)規則,也就是確定對象轉換後內存管理 ownership 的改變。

If you cast between Objective-C and Core Foundation-style objects, you need to tell the compiler about the ownership semantics of the object using either a cast (defined in objc/runtime.h) or a Core Foundation-style macro (defined in NSObject.h)

於是蘋果在引入 ARC 後,對 Toll-Free Bridging 也加入了對應方法與修飾符,用來指明用哪種規則管理內存。這些方法和修飾符分別是:

__bridge(修飾符)

只是聲明類型轉變,但不做內存管理規則的轉變。比如:

CFStringRef s1 = (__bridge CFStringRef)[[NSString alloc] initWithFormat:@"Hello, %@!", name];

只做了 NSString 到 CFStringRef 的轉化,管理規則未變,仍要用 ARC 管理 s1,不能用 CFRelease() 釋放它。

__bridge_retained(修飾符)or CFBridgingRetain(函數)

表示轉變指針類型的同時,把內存管理責任由原來的 Objective-C 交給 Core Foundation,即將 ARC 轉變為 MRC。比如:

NSString *s1 = [[NSString alloc] initWithFormat:@"Hello, %@!", name];
CFStringRef s2 = (__bridge_retained CFStringRef)s1;
// do something with s2
// ...
CFRelease(s2); // 注意使用結束後加這個

此時內存管理規則由 ARC 變為 MRC,我們需手動管理 s2,而對於 s1,即使置 nil 也不能釋放內存。等價寫法:

NSString *s1 = [[NSString alloc] initWithFormat:@"Hello, %@!", name];
CFStringRef s2 = (CFStringRef)CFBridgingRetain(s1);
// do something with s2
// ...
CFRelease(s2); // 注意使用結束後加這個

__bridge_transfer(修飾符)or CFBridgingRelease(函數)

這個修飾符和函數功能與 __bridge_retained 相反,表示把管理責任由 Core Foundation 轉交給 Objective-C,即由 MRC 轉為 ARC。比如:

CFStringRef result = CFURLCreateStringByAddingPercentEscapes(. . .);
NSString *s = (__bridge_transfer NSString *)result;
// or
NSString *s = (NSString *)CFBridgingRelease(result);
return s;

這裡把 result 的管理責任交給 ARC,就不再需要顯式調用 CFRelease()。

你可能會注意到一個細節:和 ARC 那 4 個主要修飾符(__strong、__weak…)不同,這裡修飾符的位置是放在類型前面的,看官方頭文件即可知道,別把位置寫錯。

好了,以上就是本文主要内容。

(本文作者:不忘初「辛」)

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