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

iOS Block 源碼分析(二):局部變量截獲與 __block 的原理

編輯:iOS 開發綜合

這次來聊聊 Block 是如何截獲自動變量的,以及 __block 背後的原理到底是什麼。

直接上代碼:

#include "stdio.h"
int main(){
    int a = 100;
    int b = 200;
    const char *ch = "b = %d\n";
    void (^block)(void) = ^{
        printf(ch, b);
    };
    b = 300;
    ch = "value had changed.b = %d\n";
    block();
    return 0;
}

底層轉換後的代碼如下:

struct __block_impl {
    void *isa;
    int Flags;
    int Reserved;
    void *FuncPtr;
};
struct __main_block_impl_0 {
    struct __block_impl impl;
    struct __main_block_desc_0* Desc;
    const char *ch;
    int b;
    __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, const char *_ch, int _b, int flags=0) : ch(_ch), b(_b) {
        impl.isa = &_NSConcreteStackBlock;
        impl.Flags = flags;
        impl.FuncPtr = fp;
        Desc = desc;
    }
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
    const char *ch = __cself->ch; // bound by copy
    int b = __cself->b;         // bound by copy
    printf(ch, b);
}
static struct __main_block_desc_0 {
    size_t reserved;
    size_t Block_size;
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0)};
int main(){
    int a = 100;
    int b = 200;
    const char *ch = "b = %d\n";
    void (*block)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, ch, b));
    b = 300;
    ch = "value had changed.b = %d\n";
    ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
    return 0;
}

基本結構在第一篇已經介紹完了,這裡重點看截獲帶來的變化。

1. 先看 Block 的內部結構本尊,以及截獲後的區別

struct __main_block_impl_0 {
    struct __block_impl impl;
    struct __main_block_desc_0* Desc;
    const char *ch;
    int b;
    __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, const char *_ch, int _b, int flags=0) : ch(_ch), b(_b) {
        impl.isa = &_NSConcreteStackBlock;
        impl.Flags = flags;
        impl.FuncPtr = fp;
        Desc = desc;
    }
};

根據 main 函數中的 Block 語法,這裡把 Block 表達式裡用到的局部變量,作為成員變量追加到了 __main_block_impl_0 結構體中。

值得注意的是:
@ 結構體內聲明的成員變量類型與局部變量完全相同。
@ 語法中沒有用到的局部變量(例如這裡的 a)不會被追加。
@ 這裡截獲的 ch 是不可修改的,而且捕捉到的 b 只是截獲了該局部變量的值而已。

2. 再看該結構體實例化的構造函數與調用

__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, const char *_ch, int _b, int flags=0) : ch(_ch), b(_b) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
}
void (*block)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, ch, b));

傳給構造函數的參數,用來對由局部變量追加的成員變量進行初始化。這裡傳入的僅僅是 ch 和 b 的值,可理解為把 Block 表達式裡截獲的局部變量追加到 __main_block_impl_0 的成員並賦值。初始化後:

impl.isa = &_NSConcreteStackBlock;
impl.Flags = 0;
impl.FuncPtr = __main_block_func_0;
Desc = &__main_block_desc_0_DATA;
ch = "b=%d\n";
b = 200;

由此可見,__main_block_impl_0 這個結構體(即 Block 本體)對自動變量進行了截獲。

3. 最後看調用 Block 時的區別

((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
    const char *ch = __cself->ch; // bound by copy
    int b = __cself->b;         // bound by copy
    printf(ch, b);
}

可以看出 block() 這句調用轉換後的方式沒有任何變化,仍是 (*block->impl.FuncPtr)(block),並把結構體本身作為參數傳遞。

現在注意 __main_block_func_0 這個 C 函數:它對傳入的 block 結構體參數進行變量獲取 __cself->ch 和 __cself->b(這兩個變量已在 Block 表達式之前聲明),最終打印出來。

一句話總結:所謂「截獲自動變量」,無非就是在執行 Block 語法時,把用到的局部變量值保存到 Block 的結構體實例(即 Block 本體)當中。

仔細看就會發現,Block 捕獲的變量就像「帶有局部變量值的匿名函數」,僅僅截獲局部變量的值。如果在 Block 內部改寫局部變量,並不會改變原先截獲的值。例如:

int a = 0;
void (^block)(void) = ^{ a = 1 };

這樣寫會直接編譯報錯!從 __main_block_impl_0 的實現上也能看出,它並不允許改寫捕獲變量的值。

簡單分隔一下:上面介紹了值的捕獲,那麼如何解決在 Block 中修改值?

第一種方法:運用 C 語言中的變量

@ 靜態變量
@ 靜態全局變量
@ 全局變量

#include "stdio.h"
int global_val = 1;          // 全局變量
static int static_global_val = 2; // 靜態全局
int main(){
    static int static_val = 3; // 靜態局部
    void (^block)(void) = ^{
        global_val *= 1;
        static_global_val *= 2;
        static_val *= 3;
    };
    block();
    printf("%d\n", global_val);
    printf("%d\n", static_global_val);
    printf("%d\n", static_val);
}

全局變量和靜態全局變量問題不大,出了作用域照樣能訪問;但靜態局部變量若去掉 static,按上面那種寫法就會報錯,原因就是實現上不能改寫捕獲的局部變量的值。

那能改寫的情況是什麼呢?答案是讓 Block 截獲局部變量的指針。看 clang 源碼:

int global_val = 1;
static int static_global_val = 2;
struct __main_block_impl_0 {
    struct __block_impl impl;
    struct __main_block_desc_0* Desc;
    int *static_val;
    __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int *_static_val, int flags=0) : static_val(_static_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_val = __cself->static_val; // bound by copy
    global_val *= 1;
    static_global_val *= 2;
    (*static_val) *= 3;
}
static struct __main_block_desc_0 {
    size_t reserved;
    size_t Block_size;
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0)};
int main(){
    static int static_val = 3;
    void (*block)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, &static_val));
    ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
    printf("%d\n", global_val);
    printf("%d\n", static_global_val);
    printf("%d\n", static_val);
}

區別很明顯:
@ __main_block_impl_0 結構體中追加的成員變量變成了 int *static_val 指針。
@ 結構體實例化時傳入的參數也變為 &static_val 地址。

也就是說,Block 語法轉換而來的 C 靜態函數通過 static_val 的指針來訪問;初始化時把靜態變量的地址傳給結構體並保存,這是超出作用域使用變量最簡單的方法。

第二種方法:使用大家熟知的 __block 修飾符

__block int a = 0;
void (^block)(void) = ^{ a = 1 };

把之前編譯報錯的代碼加上 __block 修飾符,再讓 clang 轉成源碼看看,代碼量直接暴增,又能展開好幾篇分析。

struct __Block_byref_a_0 {
    void *__isa;
    __Block_byref_a_0 *__forwarding;
    int __flags;
    int __size;
    int a;
};
struct __main_block_impl_0 {
    struct __block_impl impl;
    struct __main_block_desc_0* Desc;
    __Block_byref_a_0 *a; // by ref
    __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_a_0 *_a, int flags=0) : a(_a->__forwarding) {
        impl.isa = &_NSConcreteStackBlock;
        impl.Flags = flags;
        impl.FuncPtr = fp;
        Desc = desc;
    }
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
    __Block_byref_a_0 *a = __cself->a; // bound by ref
    (a->__forwarding->a) = 1;
}
static void __main_block_copy_0(struct __main_block_impl_0 *dst, struct __main_block_impl_0 *src) {
    _Block_object_assign((void*)&dst->a, (void*)src->a, 8/*BLOCK_FIELD_IS_BYREF*/);
}
static void __main_block_dispose_0(struct __main_block_impl_0 *src) {
    _Block_object_dispose((void*)src->a, 8/*BLOCK_FIELD_IS_BYREF*/);
}
static struct __main_block_desc_0 {
    size_t reserved;
    size_t Block_size;
    void (*copy)(struct __main_block_impl_0*, struct __main_block_impl_0*);
    void (*dispose)(struct __main_block_impl_0*);
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0), __main_block_copy_0, __main_block_dispose_0};
int main(){
    __attribute__((__blocks__(byref))) __Block_byref_a_0 a = {(void*)0, (__Block_byref_a_0 *)&a, 0, sizeof(__Block_byref_a_0), 0};
    void(*blk)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_a_0 *)&a, 570425344));
    return 0;
}

分析一個 __block 多了這麼多代碼和結構,著實讓人眼花。__block int a = 0; 分解為:

__Block_byref_a_0 a = {(void*)0, (__Block_byref_a_0 *)&a, 0, sizeof(__Block_byref_a_0), 0};

加上了 __block 後,a 變成了一個結構體實例,在棧上生成了 __Block_byref_a_0 結構體實例,a 初始化為 0,這個值也出現在結構體的成員變量中,意味著該結構體持有相當於原局部變量的成員變量。

來看看它的結構:

struct __Block_byref_a_0 {
    void *__isa;
    __Block_byref_a_0 *__forwarding;
    int __flags;
    int __size;
    int a;
};

其中最後一個 int a 就是原局部變量的成員變量。

再看 void (^block)(void) = ^{ a = 1 }; 分解為:

void(*blk)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_a_0 *)&a, 570425344));

仍是調用 __main_block_impl_0 的初始化,但由於 a 加了 __block 修飾符,傳入的不再是 &a 的地址,而是換成 __Block_byref_a_0 結構體實例的指針(該結構體也是個對象,最後的屬性放著需要截獲的局部變量)。

對應的 block 塊函數轉換為 C:

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
    __Block_byref_a_0 *a = __cself->a; // bound by ref
    (a->__forwarding->a) = 1;
}

對比兩個方案:第一個用 C 語言的靜態變量,直接操作靜態變量的指針即可;而 __block 則複雜得多。Block 的結構體實例持有指向 __block 變量 __Block_byref_a_0 結構體實例的指針。

__Block_byref_a_0 結構體實例的成員變量 __forwarding 持有指向該結構體實例自身的指針,通過 __forwarding 訪問成員變量 a。

來一張示意圖幫助理解:

另外要提一點,__block 內部的 __Block_byref_a_0 也是獨立的結構體實例,不屬於 __main_block_impl_0 結構體,這樣便於在多個 Block 中都能訪問同一個 __block 變量。

後續預告:Block 超出作用域變量仍能存在的理由、__forwarding 存在的理由,以及源碼中新增的 copy 和 dispose 函數,之後再細看。

總結

1. 普通局部變量被 Block 截獲只是單純截獲其值,並追加到 __main_block_impl_0 結構體中(無法修改重寫)。
2. 要允許 Block 修改值有兩個方法:一是用 C 語言的變量(代表是靜態局部變量),二是用 __block 修飾符。
3. __block 修飾的變量其實變成了對象結構體 __Block_byref_a_0,初始化 __main_block_impl_0 時追加的是這個結構體的指針。
4. 最終在 __main_block_func_0 中調用 __block 結構體指針的 forwarding 指針(此時指向自己)的成員變量 a 來重新賦值。
5. __block 生成的源碼,大致能看出類似 OC 中對象 retain/release 的一系列操作,下一節再細看。

一句話概括:__block 修飾的局部變量其實也是一個結構體實例(對象),並且以結構體指針作為參數進行初始化和調用。

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