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

深入 Block 底層:外部變量捕獲與 __block 的實現原理

編輯:iOS 開發基礎

前言

Blocks 是 C 語言的擴充功能,Apple 在 OS X Snow Leopard 與 iOS 4 中正式引入。從那時起,Block 遍布 iOS 與 Mac 的各種 API,並被廣泛使用。一句話形容:Block 就是「帶有自動變量(區域變量)的匿名函數」。

Block 在 Objective-C 中的結構大致如下:

struct Block_layout {
    void *isa;
    int flags;
    int reserved;
    void (*invoke)(void *, ...);
    struct Block_descriptor *descriptor;
    /* Imported variables. */
};

struct Block_descriptor {
    unsigned long int reserved;
    unsigned long int size;
    void (*copy)(void *dst, void *src);
    void (*dispose)(void *);
};

從結構不難看到 isa——這說明 OC 是把 Block 當作物件來處理的。iOS 中常見的三種是 _NSConcreteStackBlock、_NSConcreteMallocBlock、_NSConcreteGlobalBlock(另外在 GC 環境下還有 _NSConcreteFinalizingBlock、_NSConcreteAutoBlock、_NSConcreteWeakBlockVariable 三種,本文暫不討論)。

接下來我們把焦點放在兩個問題上:Block 如何捕獲外部變量,以及 __block 的實現原理。

研究工具:clang

想看編譯器做了什麼,可以用 clang 把 Objective-C 源碼改寫成 C / C++:

clang -rewrite-objc block.c

一、Block 捕獲外部變量的實質

先回顧 C 語言的變量分類,一般可分為五類:自動變量、函數參數、靜態變量、靜態全局變量、全局變量。研究 Block 的捕獲行為時排除函數參數,逐一驗證其餘四類。

把四類變量寫進同一段測試程式碼,編譯器立刻報錯:自動變量沒有加 __block。由於 __block 有點複雜,我們先只驗證靜態變量、靜態全局變量與全局變量這三類。

#import 

int global_i = 1;
static int static_global_j = 2;

int main(int argc, const char * argv[]) {
    static int static_k = 3;
    int val = 4;

    void (^myBlock)(void) = ^{
        global_i++;
        static_global_j++;
        static_k++;
        NSLog(@"Block中 global_i = %d, static_global_j = %d, static_k = %d, val = %d",
              global_i, static_global_j, static_k, val);
    };

    global_i++;
    static_global_j++;
    static_k++;
    val++;
    NSLog(@"Block外 global_i = %d, static_global_j = %d, static_k = %d, val = %d",
          global_i, static_global_j, static_k, val);

    myBlock();
    return 0;
}

執行結果:

Block外  global_i = 2, static_global_j = 3, static_k = 4, val = 5
Block中  global_i = 3, static_global_j = 4, static_k = 5, val = 4

兩個現象需要解釋:

  1. 為什麼 Block 裡不加 __block 就不允許修改變量?
  2. 為什麼自動變量的值沒有跟著增加,其他三個卻增加了?自動變量是以什麼狀態被捕獲的?

用 clang 轉換一次源碼來看(原本 37 行、832 bytes 的 main.m,轉換後暴漲到 10 萬多行、3.1MB):

int global_i = 1;
static int static_global_j = 2;

struct __main_block_impl_0 {
    struct __block_impl impl;
    struct __main_block_desc_0* Desc;
    int *static_k;
    int val;

    __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc,
                        int *_static_k, int _val, int flags = 0)
        : static_k(_static_k), val(_val) {
        impl.isa = &_NSConcreteStackBlock;
        impl.Flags = flags;
        impl.FuncPtr = fp;
        Desc = desc;
    }
};

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
    int *static_k = __cself->static_k;   // bound by copy
    int val = __cself->val;             // bound by copy

    global_i++;
    static_global_j++;
    (*static_k)++;
    NSLog(..., global_i, static_global_j, (*static_k), val);
}

全局變量與靜態全局變量

這兩個變量的值增加、並在 Block 內外都生效,很好理解:它們作用域廣、存放在全局區,Block 只是直接存取同一份記憶體,++ 之後的值自然會保留。

自動變量與靜態變量:被捕獲成成員變量

在 __main_block_impl_0 中可以看到,靜態變量 static_k 與自動變量 val 都被「搬」進來,成了這個結構體的成員變量;構造函數也多出了對應的兩個參數。

__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc,
                    int *_static_k, int _val, int flags = 0)
    : static_k(_static_k), val(_val)

初始化時是這樣傳入的:

void (*myBlock)(void) = ((void (*)())&__main_block_impl_0(
    (void *)__main_block_func_0, &__main_block_desc_0_DATA, &static_k, val));

impl.isa = &_NSConcreteStackBlock;
impl.Flags = 0;
impl.FuncPtr = __main_block_func_0;
Desc = &__main_block_desc_0_DATA;

結論:執行 Block 表達式時,Block 用到的自動變量當下的值會被存進 Block 結構體實例中,也就是存進 Block 自己裡面。

順帶一提,如果外層還有很多自動變量、靜態變量,但 Block 內部完全沒用到,它們就不會被捕獲,也不會出現在構造函數的參數清單裡。Block 只捕獲閉包內真正會用到的變量。

為什麼自動變量改不了

再看 __main_block_func_0 的實現,編譯器自動加上的註解是 bound by copy:自動變量 val 雖然被捕獲,卻是以 __cself->val 的方式讀取。Block 只拿到了值,沒有拿到 val 的記憶體位址,所以即使在 Block 內改寫 val,也無法影響外層那個真正的 val。

Objective-C 很可能正是基於這一點,在編譯階段就直接擋掉開發者的誤用:

Variable is not assignable (missing __block type specifier)

小結一下第二個問題:自動變量以值傳遞的方式進入 Block 的構造函數;Block 只捕獲會用到的變量;因為只捕獲值而非位址,Block 內部無法改變自動變量。能被改變的是靜態變量、靜態全局變量與全局變量。

第一個問題:為什麼那三類可以改

  1. 靜態全局變量與全局變量因為作用域廣,存在全局區,可以直接在 Block 內修改。
  2. 靜態變量傳給 Block 的是記憶體位址,所以能直接改值。

依照官方文件,蘋果的作法是:在自動變量前加上 __block 關鍵字(__block storage-class-specifier),就能在 Block 內改變外部自動變量。

於是在 Block 中改變變量值共有兩條路:傳入記憶體位址指標,或改變儲存區(__block)。

方式一:傳入記憶體位址

NSMutableString *str = [[NSMutableString alloc] initWithString:@"Hello,"];

void (^myBlock)(void) = ^{
    [str appendString:@"World!"];
    NSLog(@"Block中 str = %@", str);
};

NSLog(@"Block外 str = %@", str);
myBlock();

輸出:

Block外  str = Hello,
Block中  str = Hello,World!

值確實被改變了。轉換源碼後可以看到,傳進結構體的是物件指標:

struct __main_block_impl_0 {
    struct __block_impl impl;
    struct __main_block_desc_0* Desc;
    NSMutableString *str;

    __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc,
                        NSMutableString *_str, int flags = 0) : str(_str) { ... }
};

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
    NSMutableString *str = __cself->str;   // bound by copy
    // 呼叫 appendString:
}

至於源碼裡多出來的 copy 與 dispose,下一節再說。

二、Block 的 copy 與 dispose

三種類型的區別(從捕獲外部變量的角度)

  • _NSConcreteStackBlock:只用到外部區域變量或成員屬性、且沒有強指標引用的 Block。生命週期由系統掌控,作用域一結束就被銷毀。
  • _NSConcreteMallocBlock:被強指標或 copy 修飾的屬性引用時,會複製一份到堆上。沒有強引用即釋放,生命週期由開發者掌控。
  • _NSConcreteGlobalBlock:沒用到外界變量,或只用到全局變量、靜態變量的 Block。生命週期從建立到程式結束。

沒用到外部變量是 GlobalBlock 很好理解;但「只用到全局變量、靜態變量」同樣屬於 GlobalBlock:

void (^myBlock)(void) = ^{
    NSLog(@"Block中 變量 = %d %d %d", static_global_j, static_k, global_i);
};
NSLog(@"%@", myBlock);

輸出:

<__NSGlobalBlock__: 0x100001050>
Block中 變量 = 2 3 1

所以在 ARC 環境下,三種類型都可以捕獲外部變量。

三種類型的區別(從持有物件與否的角度)

StackBlock 不持有物件(以下在 MRC 下執行):

NSObject *obj = [[NSObject alloc] init];
NSLog(@"1.Block外 obj = %lu", (unsigned long)obj.retainCount);
void (^myBlock)(void) = ^{
    NSLog(@"Block中 obj = %lu", (unsigned long)obj.retainCount);
};
NSLog(@"2.Block外 obj = %lu", (unsigned long)obj.retainCount);
myBlock();

輸出:retainCount 全程為 1。

MallocBlock 持有物件:

void (^myBlock)(void) = [^{
    NSLog(@"Block中 obj = %lu", (unsigned long)obj.retainCount);
} copy];

輸出:Block 外 1 → 2 → Block 中 2 → release 後回到 1。

GlobalBlock 不持有物件:Block 內部自行建立的物件,retainCount 為 1。

由於 StackBlock 所屬的作用域一結束就會被銷毀,ARC 下編譯器會自動把 Block 從棧複製到堆。以下四種情況系統會自動 copy:

  1. 手動呼叫 copy
  2. Block 作為函數回傳值
  3. Block 被強引用(賦值給 __strong 或 id 類型)
  4. 呼叫帶 usingBlock 參數的系統 API

但當 Block 是函數參數時,就需要自己手動 copy 到堆上(GCD 等系統 API 除外)。

copy 與 release 的底層實現

#define Block_copy(...) ((__typeof(__VA_ARGS__))_Block_copy((const void *)(__VA_ARGS__)))
#define Block_release(...) _Block_release((const void *)(__VA_ARGS__))

_Block_copy_internal 完成了 StackBlock 到 MallocBlock 的轉換,可以拆成幾個關鍵步驟:

static void *_Block_copy_internal(const void *arg, const int flags) {
    struct Block_layout *aBlock;
    const bool wantsOne = (WANTS_ONE & flags) == WANTS_ONE;

    if (!arg) return NULL;
    aBlock = (struct Block_layout *)arg;

    // 已在堆上:增加引用計數後直接返回
    if (aBlock->flags & BLOCK_NEEDS_FREE) {
        latching_incr_int(&aBlock->flags);
        return aBlock;
    }
    // 全局 Block:直接返回,不需要複製
    else if (aBlock->flags & BLOCK_IS_GLOBAL) {
        return aBlock;
    }

    // 配置堆記憶體並逐位元搬移
    struct Block_layout *result = malloc(aBlock->descriptor->size);
    if (!result) return (void *)0;
    memmove(result, aBlock, aBlock->descriptor->size);

    result->flags = ~(BLOCK_REFCOUNT_MASK);
    result->flags |= BLOCK_NEEDS_FREE | 1;
    result->isa = _NSConcreteMallocBlock;

    // 若有 copy/dispose,則修正物件欄位
    if (result->flags & BLOCK_HAS_COPY_DISPOSE) {
        (*aBlock->descriptor->copy)(result, aBlock);
    }
    return result;
}

_Block_release 則負責銷毀:先遞減引用計數,若還有剩就直接返回;否則依標記決定是呼叫 dispose 並釋放記憶體,還是什麼都不做(GlobalBlock)。對棧上的 Block 呼叫 release 只會印出警告並忽略。

為什麼會多出 copy 與 dispose

回到字串那個例子,轉換後的 __main_block_desc_0 多了兩個成員:

static void __main_block_copy_0(struct __main_block_impl_0 *dst,
                                struct __main_block_impl_0 *src) {
    _Block_object_assign((void*)&dst->str, (void*)src->str, 3 /*BLOCK_FIELD_IS_OBJECT*/);
}

static void __main_block_dispose_0(struct __main_block_impl_0 *src) {
    _Block_object_dispose((void*)src->str, 3 /*BLOCK_FIELD_IS_OBJECT*/);
}

原因是:C 結構體本身無法很好地處理初始化與銷毀,對記憶體管理不利。於是編譯器在 descriptor 中插入 copy 與 dispose 兩個函式指標,藉 Objective-C Runtime 完成記憶體管理。這裡的 _Block_object_assign 與 _Block_object_dispose 就對應 retain 與 release。

而 BLOCK_FIELD_IS_OBJECT 是 Block 截獲物件時的標記;若截獲的是 __block 變量,標記會變成 BLOCK_FIELD_IS_BYREF。

三、__block 的實現原理

非物件變量

__block int i = 0;
void (^myBlock)(void) = ^{
    i++;
    NSLog(@"%d", i);
};
myBlock();

轉換後的源碼:

struct __Block_byref_i_0 {
    void *__isa;
    __Block_byref_i_0 *__forwarding;
    int __flags;
    int __size;
    int i;
};

struct __main_block_impl_0 {
    struct __block_impl impl;
    struct __main_block_desc_0* Desc;
    __Block_byref_i_0 *i;   // by ref

    __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc,
                        __Block_byref_i_0 *_i, int flags = 0)
        : i(_i->__forwarding) { ... }
};

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
    __Block_byref_i_0 *i = __cself->i;   // bound by ref
    (i->__forwarding->i)++;
    NSLog(..., (i->__forwarding->i));
}

帶 __block 的變量同樣被轉化成一個結構體,共五個成員:isa 指標、指向自身類型的 __forwarding 指標、flag 標記、自身大小,以及與變量同名的值。初始化時 __forwarding 傳入的是自己的位址:

__attribute__((__blocks__(byref))) __Block_byref_i_0 i =
    {(void*)0, (__Block_byref_i_0 *)&i, 0, sizeof(__Block_byref_i_0), 0};

__forwarding 永遠指向自己嗎?

做個實驗(MRC 環境),把 Block copy 到堆上之後,再印出 Block 內外的 &i:

__block int i = 0;
NSLog(@"%p", &i);
void (^myBlock)(void) = [^{
    i++;
    NSLog(@"這是Block裡面 %p", &i);
} copy];

輸出:

0x7fff5fbff818 <__NSMallocBlock__: 0x100203cc0>
這是Block裡面 0x1002038a8

兩者相差 1052 位元組,說明 __forwarding 已經不再指向原來的自己了。原因就在於 Block 被 copy 到堆上:堆上的 Block 會持有它捕獲的物件,也會複製一份 __block 變量;當 Block 釋放時,若沒有其他引用,這份 __block 也會一起被銷毀。

__forwarding 的作用於此明朗:原本它指向自己,Block 被複製到堆上後,改成指向堆上那份複製出來的自己;而堆上變量的 __forwarding 再指向它自己。如此一來,不論 __block 在堆上還是棧上,都能透過 (i->__forwarding->i) 正確取到值。

MRC 與 ARC 的差異

如果 Block 沒有被 copy(以下 MRC 環境):

__block int i = 0;
NSLog(@"%p", &i);
void (^myBlock)(void) = ^{ i++; NSLog(@"Block裡面的 %p", &i); };
NSLog(@"%@", myBlock);
myBlock();

輸出:

0x7fff5fbff818 <__NSStackBlock__: 0x7fff5fbff7c0>
 0x7fff5fbff818

Block 捕獲 __block 變量後並未複製到堆上,位址始終留在棧上,__forwarding 也只指向自己。

而在 ARC 環境下,只要 Block 有賦值動作就會觸發 copy,__block 幾乎都會被複製到堆上,Block 也成為 __NSMallocBlock。不過 ARC 下依然存在 __NSStackBlock——例如下面這種沒有賦值、直接建立並呼叫的寫法:

__block int temp = 10;
NSLog(@"%@", ^{ NSLog(@"*******%d %p", temp++, &temp); });

輸出:

<__NSStackBlock__: 0x7fff5fbff768>

之所以平時最常見到 MallocBlock,是因為我們通常會把 Block 賦值給變量,而 ARC 下透過 = 傳遞會觸發 objc_retainBlock → _Block_copy → _Block_copy_internal 這條呼叫鏈,使 StackBlock 轉為 MallocBlock。

物件變量

// ARC 環境
__block id block_obj = [[NSObject alloc] init];
id obj = [[NSObject alloc] init];

NSLog(@"block_obj = [%@ , %p] , obj = [%@ , %p]", block_obj, &block_obj, obj, &obj);

void (^myBlock)(void) = ^{
    NSLog(@"***Block中****block_obj = [%@ , %p] , obj = [%@ , %p]",
          block_obj, &block_obj, obj, &obj);
};
myBlock();

輸出:

block_obj = [<NSObject: 0x100b027d0> , 0x7fff5fbff7e8] , obj = [<NSObject: 0x100b03b50> , 0x7fff5fbff7b8]
Block中 block_obj = [<NSObject: 0x100b027d0> , 0x100f000a8] , obj = [<NSObject: 0x100b03b50> , 0x100f00070]

轉換後可以看到,__Block_byref_block_obj_0 比非物件版本多了兩個函式指標 __Block_byref_id_object_copy 與 __Block_byref_id_object_dispose,負責該物件在複製與銷毀時的記憶體管理。

另外要記住:OC 中物件變量預設自帶 __strong 修飾符,因此

__block id block_obj = [[NSObject alloc] init];
id obj = [[NSObject alloc] init];

等價於

__block id __strong block_obj = [[NSObject alloc] init];
id __strong obj = [[NSObject alloc] init];

從打印結果看,ARC 下 Block 捕獲外部物件變量時兩者位址都不同(都複製了一份),差別只在於帶 __block 的變量會被 Block 內部持有。

同樣的程式碼放到 MRC 下執行,Block 內外的位址完全相同——此時 Block 是 __NSStackBlock__,retainCount 都是 1;一旦 copy 成 __NSMallocBlock__,retainCount 才變成 2。

總結

回到開頭的五類變量。嚴格來說,只有自動變量與靜態變量會成為 __main_block_impl_0 的成員變量,也就是真正被「捕獲」;捕獲進來的物件會被 Block 持有。

非物件變量方面:

  • 不帶 __block 的自動變量,值被 copy 進 Block,只能讀取不能修改。
  • 帶 __block 的自動變量與靜態變量,是直接位址存取,因此可以在 Block 內改值。
  • 靜態全局變量、全局變量、函數參數同樣能在 Block 內改值,但它們並未變成結構體的成員變量,只是因為作用域夠大。它們不會被 Block 持有,也不會增加 retainCount。

物件方面:MRC 下 __block 不會對指標指向的物件執行 copy,只是複製指標;ARC 下,宣告為 __block 的外部物件會在 Block 內部被 retain,以確保 Block 執行期間能安全引用外部物件——這也正是循環引用問題的根源。

把「捕獲變量」與「持有變量」這兩個概念分清楚,後續處理 Block 循環引用時才不會靠猜。

本文最初版本對 ARC 下 StackBlock 的說明不夠嚴謹,感謝 @酷酷的哀殿 指正、@bestswifter 指點,已在文中更新。

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