Objective-C中block的底層原理

先出2個考題：

一、

上面打印的是幾，captureNum2 出去做用域後是否被銷燬？爲何？

 

一樣類型的題目：

 

問：打印的數字爲多少？

有人會回答：mutArray是captureObject方法的局部變量，mutArray指針 保存到棧上，那麼當執行完captureObject方法後，出去了做用域mutArray變量就會被系統自動釋放。

因此當執行captureBlk([[NSObject alloc] init]); 的時候，mutArray爲nil，每次打印的爲0。

 

固然上面說的是錯的。

打印出來的值分別是 1，2，3。

那麼若是把上面代碼中的mutArray改成weak類型：

NSMutableArray __weak *mutArray = [[NSMutableArray alloc] init];

結果又會是什麼呢。

 

二、下面代碼分別打印的值是多少。爲何？

 

本文會分析上面的代碼中block底層 都作了哪些操做。

 

用過block的能夠 直接忽略前面的語法部分。直接從第三部分看便可。

 

1、block的使用

iOS4.0開始進入block特性。也叫作閉包。是一個函數（或指向函數的指針），再加上該函數執行的外部的上下文變量（有時候也稱做自由變量）。

一、block的聲明：

void (^blockName)(int arg1, int arg2);

中文翻譯：返回值(^block變量名)(block的參數)

參數名稱能夠省略，也能夠寫成：

void (^blockName)(int, int);

 

二、block的定義：

^void(int arg1, int arg2) {

};

中文翻譯：^返回類型(block的參數)

返回類型能夠省略，也能夠寫成：

^(int arg1, int arg2) {};

 

聲明定義和調用：

    void (^blockName)(int, int) = ^(int arg1, int arg2) {
        NSLog(@"arg1 + arg2 = %d", arg1 + arg2);
    };
    blockName(1,2);

block沒有參數、有返回值、做爲方法的參數：

- (void)viewDidLoad {
    //二、沒有參數
    void (^blockName2)() = ^() {
        NSLog(@"block2");
    };
    blockName2();
    
    //三、block有返回值
    int (^blockName3)(int) = ^(int n) {
        return n * 2;
    };
    //四、block做爲方法的參數
    [self testBlock2:blockName3];
}

- (void)testBlock2:(int(^)(int))myBlock {
    myBlock(10);
}

  

三、block只有在調用的時候纔會執行裏面的函數內容。

 

2、block調用外部變量

一、全局變量，block能夠進行讀取和修改。

@interface ViewController () {
    NSInteger num;
}

@implementation ViewController

- (void)viewDidLoad {
    //一、block修改爲員變量
    void (^block1)() = ^(){
        ++num;
        NSLog(@"調用成員變量： %ld", num);
    };
    
    block1();
}

 

二、局部變量，block只能讀取，不能修改局部變量。這個時候是值傳遞。

若是想修改局部變量，要用__block來修飾。這個時候是引用傳遞。下面會聊下block的實現原理。

看例子：

    //二、調用局部變量，不用__block
    NSInteger testNum2 = 10;
    void (^block2)() = ^() {
        //testNum = 1000; 這樣是編譯不經過的
        NSLog(@"修改局部變量： %ld", testNum2); //打印：10
    };
    testNum2 = 20;
    block2();
    NSLog(@"testNum最後的值： %ld", 20);//打印：30

    //三、修改局部變量，要用__block
    __block NSInteger testNum3 = 10;
    void (^block3)() = ^() {
        NSLog(@"讀取局部變量： %ld", testNum3); //打印：20
        testNum3 = 1000;
        NSLog(@"修改局部變量： %ld", testNum3); //打印：1000
    };
    testNum3 = 20;
    block3();
    testNum3 = 30;
    NSLog(@"testNum最後的值： %ld", testNum3);//打印：30

 

3、block代碼分析

網上不少經過Clang（LLVM編譯器）將OC的代碼轉換成C++源碼，來進行分析的。可是這些轉換的代碼並非block的源代碼，只是用來理解用的過程代碼。

一、block不包含任何變量

新建一個testBlock.m文件。文件中代碼爲：

 

執行clang命令：

 clang -rewrite-objc testBlock.m

生成.cpp的核心代碼主要在.cpp文件的底部，你們能夠看下圖：

 

我加了比較詳細的註釋，具體的看圖片就好。這裏重點強調下關鍵的東東：

1.一、其中block的結構體：

struct __block_impl
{
    void *isa;
    int Flags;
    int Reserved;
    void *FuncPtr;
};

 

isa：isa指針，在Objective-C中，任何對象都有isa指針。block 有三種類型：

_NSConcreteGlobalBlock：全局的靜態 block，相似函數。若是block裏不獲取任何外部變量。或者的變量是全局做用域時，如成員變量、屬性等； 這個時候就是Global類型

_NSConcreteStackBlock：保存在棧中的 block，棧都是由系統管理內存，當函數返回時會被銷燬。__block類型的變量也一樣被銷燬。爲了避免被銷燬，block會將block和__block變量從棧拷貝到堆。

_NSConcreteMallocBlock：保存在堆中的 block，堆內存能夠由開發人員來控制。當引用計數爲 0 時會被銷燬。

代碼執行的時候，block的isa有上面3中值。後面還會進行詳細的說明。

 

1.二、__main_block_func_0 是block要執行的函數：

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
        printf("打印block函數");
}

 

1.三、__main_block_desc_0 是block的描述信息 的結構體

1.四、block的類型。

 在上圖中能夠看到：

impl.isa = &_NSConcreteStackBlock; 

這裏 impl.isa 的類型爲_NSConcreteStackBlock，因爲 clang 改寫的具體實現方式和 LLVM 不太同樣，因此這裏 isa 指向的仍是_NSConcreteStackBlock。但在 LLVM 的實現中，開啓 ARC 時，block 應該是 _NSConcreteGlobalBlock 類型。

因此 block是什麼類型 在 clang代碼裏是看不出來的。

 

若是要查看block的類型仍是要經過Xcode進行打印：

打印的結果：

clangBlk = <__NSGlobalBlock__: 0x100054240>
打印block函數

 

上面block代碼，沒有獲取任何外部變量，應該是 _NSConcreteGlobalBlock類型的。該類型的block和函數同樣 存放在 代碼段 內存段。內存管理簡單。

 

二、block 訪問 局部變量 

 新建testBlock2.m文件，代碼以下：

 

經過clang命令生成 的核心代碼以下，和剛纔clang的代碼 不一樣的地方 已經加了註釋：

2.一、能夠看到 __main_block_impl_0 中添加了 一個int num的變量。在 __main_block_func_0中使用了該變量。

從這裏能夠看出來 這裏是 值拷貝，不能修改，只能訪問。

2.二、用Xcode打印上面block代碼，獲得的類型爲：__NSMallocBlock。

在說_NSConcreteMallocBlock類型前，咱們先說下_NSConcreteStackBlock類型。

_NSConcreteStackBlock類型的block存在棧區，當變量做用域結束的時候，這個block和block上的__block變量就會被銷燬。

這樣當block獲取了局部變量，在其餘地方訪問的時候就會崩潰。block經過copy來解決了這個問題，能夠將block從棧拷貝到堆。這樣當棧上的做用域結束後，仍然能夠訪問block和block中的外部變量。

 

咱們如今看下本文開頭的問題1：

爲何局部變量muArray出了做用域 還能存在？

captureBlk爲默認的__strong類型，當block被賦值給__strong類型的對象或者block的成員變量時，編譯器會自動調用block的copy方法。

執行copy方法，block拷貝到堆上，mutArray變量賦值給block的成員變量。因此打印的結果就爲1，2，3。

若是把上面代碼中的mutArray改成weak類型，那麼打印的就都是0了。由於當出去做用域的時候，mutArray就已經被釋放了。

 

同時，由於NSMutableArray *mutArray 是引用類型，用clang命令執行後，發現：

struct __main_block_impl_0
{
    struct __block_impl impl;
    struct __main_block_desc_0 *Desc;
    id __strong mutArray;

 .....

}

mutArray在block中是id類型，由於是指針 因此在block中mutArray是能夠修改的，而int類型的不能修改。固然若是用__block也能修改int類型的外部變量，下面咱們會詳說。

 

下面這個打印的結果是1，也是這個道理：

同時訪問外部變量是block進行的值傳遞，因此打印的仍是1，不是2。

 

2.三、什麼狀況下block會進行copy操做。

用代碼顯示的調用copy操做：

[captureBlk2 copy];

在MRC下block定義的屬性都要加上copy，ARC的時候block定義copy或strong都是能夠的，由於ARC下strong類型的block會自動完成copy的操做。

@property (nonatomic, strong) captureObjBlk2 captureBlk21;

當 block 做爲函數返回值返回時。

當 block 被賦值給 __strong id 類型的對象或 block 的成員變量時。

當 block 做爲參數被傳入方法名帶有 usingBlock 的 Cocoa Framework 方法或 GCD 的 API 時。

 

三、__block在block中的做用。

新建testBlock3.m，代碼以下：

 

用clang生成的代碼以下，進行了詳細的註釋：

 

block訪問的外部變量，在block中就是一個結構體：__Block_byref_num_0：

// 1、用於封裝 __block 修飾的外部變量
struct __Block_byref_num_0 {
    void *__isa;    // 對象指針
    __Block_byref_num_0 *__forwarding;  // 指向 拷貝到堆上的 指針
    int __flags;    // 標誌位變量
    int __size;     // 結構體大小
    int num;        // 外部變量
};

 其中 int num 爲外部變量名。

__Block_byref_num_0 *__forwarding; 這個是指向本身堆上的指針，這個後面會詳細說明。

 

爲了對__Block_byref_num_0結構體進行內存管理。新加了copy和dispose函數：

//4、對__Block_byref_num_0結構體進行內存管理。新加了copy和dispose函數。
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {
    // _Block_object_assign 函數：當 block 從棧拷貝到堆時，調用此函數。
    _Block_object_assign((void*)&dst->num, (void*)src->num, 8/*BLOCK_FIELD_IS_BYREF*/);
}

// 當 block 從堆內存釋放時，調用此函數:__main_block_dispose_0
static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->num, 8/*BLOCK_FIELD_IS_BYREF*/);}

 

__main_block_impl_0 中增長了 __Block_byref_num_0類型的指針變量。因此__block的變量之因此能夠修改 是由於 指針傳遞。因此block內部修改了值，外部也會改變：

struct __main_block_impl_0 {
    struct __block_impl impl;
    struct __main_block_desc_0* Desc;
    __Block_byref_num_0 *num; // 2、__block int num  變成了 __Block_byref_num_0指針變量。也就是 __block的變量經過指針傳遞給block
    __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_num_0 *_num, int flags=0) : num(_num->__forwarding) {
        impl.isa = &_NSConcreteStackBlock;
        impl.Flags = flags;
        impl.FuncPtr = fp;
        Desc = desc;
    }
};

 

在block要執行的函數 __main_block_func_0中，咱們經過__Block_byref_num_0的__forwarding指針來修改的 外部變量，即：(num->__forwarding->num) = 10;

 

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
    __Block_byref_num_0 *num = __cself->num; // bound by ref
    
    (num->__forwarding->num) = 10;  //3、這裏修改的是__forwarding 指向的內存的值
    printf("num = %d", (num->__forwarding->num));
}

 

這是爲何呢？

咱們先來看下文章開頭的第二個問題：

 

當外部的局部變量testNum3 改變後，block內的testNum3變量也變了。 

在block中修改的testNum3值，在block外部testNum3也改變了。

咱們看下剛纔clang生成的main方法，上面有截圖：

相似的邏輯：

用__block修改後，testNum3變量轉換爲__Block_byref_num_0 的結構體。

上面說過copy操做會將block從棧拷貝到堆上， 會把 testNum3轉成的__Block_byref_num_0 結構體  賦值給block的變量。

同時 會把 __Block_byref_num_0 的結構體中的 __forwarding指針指向拷貝到堆上 結構體。

就是棧上和拷貝到堆上的 的__Block_byref_num_0都用__forwarding指向堆上的本身。

這樣在棧上修改 testNum3變量的時候，實際修改的是堆上值，因此block內外的值是相互影響。

 

 

原本想寫下block循環引用的問題。如今寫的比較累，明天單開一章來寫這個問題吧。

 

 

本文中的全部代碼還有clang生成的.cpp文件，都放到了github上。

本文參考了MicroCai的文章。

 

 

歡迎關注個人 今日頭條號 名稱： 雲端夢想科技  

歡迎關注個人 微信公衆號：dreams2999