Block的本質

iOS開發 C++ · 發表 2018-09-10 16:28:33

摘要： Block在iOS開發中的用途非常廣，今天我們就來一起探索一下Block的底層結構。 1. Block的底層結構下面是一個沒有引數和返回值的簡單的Block： int main(int argc, char * argv[]) { @autoreleasepool { ...

Block在iOS開發中的用途非常廣，今天我們就來一起探索一下Block的底層結構。

1. Block的底層結構

下面是一個沒有引數和返回值的簡單的Block：

int main(int argc, char * argv[]) {
@autoreleasepool {

void (^block)(void) = ^{

NSLog(@"Hello World!");
};

block();

return 0;
}
}

為了探索Block的底層結構，我們將main.m檔案轉化為C++的原始碼、我們開啟命令列。cd到包含main.m檔案的資料夾，然後輸入: clang -rewrite-objc main.m ，這個時候在該資料夾的目錄下會生成main.cpp檔案。

這個檔案非常長，我們直接拉到檔案的最下面，找到main函式：

int main(int argc, char * argv[]) {
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 
//定義block
void (*block)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));
//呼叫block
((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);

return 0;
}
}

這第一行程式碼是定義一個block變數，第二行程式碼是呼叫block。這兩行程式碼看起來非常複雜。但是我們可以去簡化一下，怎麼簡化呢？

變數前面的()一般是做強制型別轉換的，比如在呼叫block這一行， block 前面有一個()是(__block_impl *)，這就是進行了一個強制型別轉換，將其轉換為一個 _block_impl 型別的結構體指標，那像這樣的強制型別轉換非常妨礙我們理解程式碼，我們可以暫時將這些強制型別轉換去掉，這樣可以幫助我們理解程式碼。

化簡後的程式碼如下：

//定義block
void (*block)(void) = &__main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA);
//呼叫block
block->FuncPtr(block);

這樣化簡後的程式碼就要清爽多了。我們一句一句的看，先看第一句：

void (*block)(void) = &__main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA);

這句程式碼的意思好像就是呼叫 _main_block_impl_0 這個函式，給這個函式傳進兩個引數 _main_block_func_0 和 &_main_block_desc_0_DATA ,然後得到這個函式的返回值，取函式返回值的地址，賦值給block這個指標。

我們在稍微上一點的位置可以找到 _main_block_impl_0 這個結構：

struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
//建構函式，類似於OC的init方法
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int flags=0) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};

__block_impl這個結構體的結構我們可以command+f在main.cpp檔案中搜索得到：

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

_main_block_desc_0結構體的結構在main.cpp檔案的最下面可以找到：

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)};

這是一個C++的結構體。而且在這個結構體內還包含一個函式，這個函式的函式名和結構體名稱一致，這在C語言中是沒有的，這是C++特有的。

在C++的結構體包含的函式稱為結構體的建構函式，它就相當於是OC中的init方法，用來初始化結構體。OC中的init方法返回的是物件本身，C++的結構體中的構造方法返回的也是結構體物件。

那麼我們就知道了， __main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA); 返回的就是 _main_block_impl_0 這個結構體物件，然後取結構體物件的地址賦值給block指標。換句話說，block指向的就是初始化後的 _main_block_impl_0 結構體物件。

我們再看一下初始化 _main_block_impl_0 結構體傳進去的引數：

第一個引數是 _main_block_func_0 ，這個引數的結構在上面一點的位置也能找到：

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {


NSLog((NSString *)&__NSConstantStringImpl__var_folders_74_wk04zv690mz36wn0g18r5nxm0000gn_T_main_3b803f_mi_0);
 }

這個函式其實就是把我們Block中要執行的程式碼封裝到這個函式內部了。我們可以看到這個函式內部就一行程式碼，就是一個NSlog函式，這也就是 NSLog(@"Hello World!"); 這句程式碼。

把這個函式指標傳給 _main_block_impl_0 的建構函式的第一個引數，然後用這個函式指標去初始化 _main_block_impl_0 這個結構體的第一個成員變數 impl 的成員變數 FuncPtr 。也就是說 FuncPtr 這個指標指向 _main_block_func_0 這個函式。

第二個引數是 &_main_block_desc_0_DATA 。

我們看一下這個結構：

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)};

在結構體的建構函式中，0賦值給了reserved， sizeof(struct __main_block_impl_0) 是賦值給了Block_size，可以看出這個結構體存放的是 _main_block_impl_0 這個結構體的資訊。在 _main_block_impl_0 的建構函式中我們可以看到， _main_block_desc_0 這個結構體的地址被賦值給了 _main_block_impl_0 的第二個成員變數 Desc 這個結構體指標。也就是說Desc這個結構體指標指向 _main_block_desc_0_DATA 這個結構體。

那麼我們總結一下：

所以第一句定義block

void (*block)(void) = &__main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA);

總結起來就是：

1.建立一個函式 _main_block_func_0 ,這個函式

的作用就是將我們block中要執行的程式碼封裝到函式內部，方便呼叫。
2.建立一個結構體 _main_block_desc_0 ,這個結構體中主要包含 _main_block_impl_0 這個結構體佔用的儲存空間大小等資訊。
3.將1中建立的 _main_block_func_0 這個函式的地址，和2中建立的 _main_block_desc_0 這個結構體的地址傳給 _main_block_impl_0 的建構函式。
4.利用 _main_block_func_0 初始化 _main_block_impl_0 結構體的第一個成員變數 impl 的成員變數 FuncPtr 。這樣 _main_bck_impl_0 這個結構體也就得到了block中那個程式碼塊的地址。
5.利用 _mian_block_desc_0_DATA 去初始化 _mian_block_impl_0 的第二個成員變數 Desc 。

下面我們再看第二步呼叫block：

block->FuncPtr(block);

我們知道，block實質上就是指向 _main_block_impl_0 這個結構體的指標，而FuncPtr是 _main_block_impl_0 的第第一個成員變數 impl 的成員變數，正常來講，block想要呼叫自己的成員變數的成員變數的成員變數，應該像下面這樣呼叫：

block->impl->FuncPtr

然而事實卻不是這樣，這是為什麼呢？

原因就在於之前我們把所有的強制型別轉換給刪掉了，之前block前面的()是(__block_impl *)，為什麼可以這樣強制轉換呢？因為block指向的是 _main_block_impl_0 這個結構體的首地址，而 _main_block_impl_0
的第一個成員變數是 struct __block_impl impl; ，所以impl和 _main_block_impl_0 的首地址是一樣的，因此指向 _main_block_impl_0 的首地址的指標也就可以被強制轉換為指向impl的首地址的指標。

之前說過，FuncPtr這個指標在建構函式中是被初始化為指向 _mian_block_func_0 這個函式的地址。因此通過 block->FuncPtr 呼叫也就獲取了 _main_block_func_0 這個函式的地址，然後對 _main_block_func_0 進行呼叫，也就是執行block中的程式碼了。這中間block又被當做引數傳進了 _main_block_func_0 這個函式。

2.變數捕獲-auto變數

auto變數是宣告在函式內部的變數，比如 int a = 0; 這句程式碼宣告在函式內部，那a就是auto變數，等價於 auto int a = 0; auto變數時分配在棧區，當超出作用域時，其佔用的記憶體會被系統自動銷燬並生成。下面看一段程式碼：

int a = 10;

void (^block)(void) = ^{

NSLog(@"%d", a);
};

a = 20;

block();

這是一個很簡單的Block捕獲自動變數的例子，我們看一下列印結果：

2018-09-04 20:39:45.436534+0800 copytest[17163:477148] 10

自動變數a的值明明已經變為了20，為什麼輸出結果還是10呢？我們把這段程式碼轉化為C++的原始碼看看。

int main(int argc, char * argv[]) {
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 

int a = 10;

void (*block)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, a));

a = 20;

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

return 0;
}
}

我們還是把程式碼化簡一下來看：

int a = 10;

void (*block)(void) = &__main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA, a);

a = 20;

block->FuncPtr)(block);

對比一下上面分析的沒有捕獲自動變數的原始碼，我們發現這裡_main_block_impl_0中傳入的引數多了一個a。然後我們往上翻看看_main_block_impl_0的結構：

struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
int a; //這是新加入的成員變數
__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;
}
};

在_main_block_impl_0這個結構體中我們發現多了一個int型別的成員變數a，在結構體的建構函式中多了一個引數int _a，並且用這個int _a去初始化成員變數a。

所以在 void (*block)(void) = &__main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA, a); 中傳入了自動變數a用來初始化_main_block_impl_0的成員變數a。那這個時候_main_block_impl_0的成員變數a就被賦值為10了。

由於上面這一步是值傳遞，所以當執行 a = 20 時，_main_block_impl_0結構體的成員變數a的值是不會隨之改變的，仍然是10。

然後我們再來看一下_main_block_func_0的結構有何變化：

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

NSLog((NSString *)&__NSConstantStringImpl__var_folders_74_wk04zv690mz36wn0g18r5nxm0000gn_T_main_fb5f0d_mi_0, a);
}

可以看到，通過傳入的_main_block_impl_0這個結構體獲得其成員變數a的值。

3.變數捕獲-static變數

上面講的捕獲的是自動變數，在函式內部宣告的變數預設為自動變數，即預設用auto修飾。那麼如果在函式內部宣告的變數用static修飾，又會帶來哪些不同呢？ static變數和auto變數的不同之處在於變數的記憶體的回收時機。auto變數在其作用域結束時就會被系統自動回收，而static變數在變數的作用域結束時並不會被系統自動回收。

先看一段程式碼：

static int a = 10;

void (^block)(void) = ^{

NSLog(@"%d", a);
};

a = 20;

block();

我們看一下列印結果：

2018-09-04 21:09:40.440020+0800 copytest[17949:499740] 20

結果是20，這個和2中的列印結果不一樣，為什麼區域性變數從auto變成了static結果會不一樣呢？我們還是從原始碼來分析：

int main(int argc, char * argv[]) {
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 

static int a = 10;

void (*block)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, &a));

a = 20;

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

return 0;
}
}

我們把程式碼化簡一下：

static int a = 10;

void (*block)(void) = &__main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA, &a);

a = 20;

block->FuncPtr(block);

和2不一樣的是，這裡傳入_main_block_impl_0的是&a，也即是a這個變數的地址值。那麼這個&a是賦值給誰了呢？我們上翻找到_main_block_impl_0的結構：

struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
int *a;
__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;
}
};

這裡我們可以看到結構體多了一個指標型別的成員變數int *a,然後在建構函式中，將傳遞過來的&a，賦值給這個指標變數。也就是說，在_main_block_impl_0這個結構體中多了一個成員變數，這個成員變數是指標，指向a這個變數。所以當a變數的值發生變化時，能夠得到最新的值。

4.變數捕獲-全域性變數

2和3分析了兩種型別的區域性變數，auto區域性變數和static區域性變數。這一部分則分析全域性變數。全域性變數會不會像區域性變數一樣被block所捕獲呢？我們還是看一下例項：

int height = 10;
static int weight = 20;

int main(int argc, char * argv[]) {
@autoreleasepool {

void (^block)(void) = ^{

NSLog(@"%d %d", height, weight);
};

height = 30;
weight = 40;

block();

return 0;
}
}

列印結果：

2018-09-04 21:41:19.016278+0800 copytest[18774:524773] 30 40

我們還是檢視一下原始碼：

int height = 10;
static int weight = 20;
int main(int argc, char * argv[]) {
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 

void (*block)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));

height = 30;
weight = 40;

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

return 0;
}
}

這裡我們可以看到，height和weight這兩個全域性變數沒有作為引數傳入_main_block_impl_0中去。然後我們再檢視一下_main_block_impl_0的結構：

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

可以看到，_main_block_impl_0中並沒有增加成員變數。然後我們再看_main_block_func_0的結構：

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {


NSLog((NSString *)&__NSConstantStringImpl__var_folders_74_wk04zv690mz36wn0g18r5nxm0000gn_T_main_46c51b_mi_0, height, weight);
}

可以看到，這個地方在呼叫的時候是直接呼叫的全域性變數height和weight。

所以我們可以得出結論， block並不會不會全域性變數。

總結：

變數型別	是否捕獲到block內部	訪問方式
區域性變數auto	是	值傳遞
區域性變數static	是	指標傳遞
全域性變數	否	直接訪問

思考為什麼對於不同型別的變數，block的處理方式不同呢？

這是由變數的生命週期決定的。對於自動變數，當作用域結束時，會被系統自動回收，而block很可能是在超出自動變數作用域的時候去執行，如果之前沒有捕獲自動變數，那麼後面執行的時候，自動變數已經被回收了，得不到正確的值。對於static區域性變數，它的生命週期不會因為作用域結束而結束，所以block只需要捕獲這個變數的地址，在執行的時候通過這個地址去獲取變數的值，這樣可以獲得變數的最新的值。gao'mi而對於全域性變數，在任何位置都可以直接讀取變數的值。

5.變數捕獲-self變數

看下面一段程式碼：

@implementation Person

- (void)test{

void(^block)(void) = ^{

NSLog(@"%@", self);
};
}

@end

這個Person類中只有一個東西，就是test這個函式，那麼這個block有沒有捕獲self變數呢？

要搞清這個問題，我們只需要知道搞清楚這裡self變數是區域性變數還是全域性變數，如果是區域性變數，那麼是一定會捕獲的，而如果是全域性變數，則一定不會被捕獲。

我們把這個Person.m檔案轉化為c++的原始碼，然後找到test函式在c++中的表示：

static void _I_Person_test(Person * self, SEL _cmd) {

void(*block)(void) = ((void (*)())&__Person__test_block_impl_0((void *)__Person__test_block_func_0, &__Person__test_block_desc_0_DATA, self, 570425344));
}

我們可以看到，本來Person.m中，這個test函式我是沒有傳任何引數的，但是轉化為c++的程式碼後，這裡傳入了兩個引數，一個是self引數，一個是_cmd。self很常見，_cmd表示test函式本身。所以我們就很清楚了，self是作為引數傳進來，也就是區域性變數，那麼block應該是捕獲了self變數，事實是不是這樣呢？我們只需要檢視一下_Person_test_block_impl_0的結構就可以知道了。

_Person_test_block_impl_0的結構：

struct __Person__test_block_impl_0 {
struct __block_impl impl;
struct __Person__test_block_desc_0* Desc;
Person *self;
__Person__test_block_impl_0(void *fp, struct __Person__test_block_desc_0 *desc, Person *_self, int flags=0) : self(_self) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};

可以看到，self確實是作為成員變數被捕獲了。

6.Block的型別

前面已經說過了，Block的本質就是一個OC物件，既然它是OC物件，那麼它就有型別。

在搞清楚Block的型別之前，先把ARC關掉，因為ARC幫我們做了太多的事，不方便我們觀察結果。關掉ARC的方法在Build Settings裡面搜尋Objective-C Automatic Reference Counting，把這一項置為NO。

int height = 10;
static int weight = 20;

int main(int argc, char * argv[]) {
@autoreleasepool {

int age = 10;

void (^block)(void) = ^{

NSLog(@"%d %d", height, age);
};

NSLog(@"%@\n %@\n %@\n %@", [block class], [[block class] superclass], [[[block class] superclass] superclass], [[[[block class] superclass] superclass] superclass]);

return 0;
}
}

上面的程式碼的列印結果是：

 __NSStackBlock__
 __NSStackBlock
 NSBlock
 NSObject

這說明上面定義的這個block的型別是NSStackBlock，並且它最終繼承自NSObject也說明Block的本質是OC物件。

Block有三種類型，分別是NSGlobalBlock,MallocBlock,NSStackBlock。

這三種類型的Block物件的儲存區域如下：

類	物件的儲存域
NSStackBlock	棧
NSGlobalBlock	程式的資料區域(.data區)
NSMallocBlock	堆

截獲了自動變數的Block是NSStackBlock型別，沒有截獲自動變數的Block則是NSGlobalStack型別,NSStackBlock型別的Block進行copy操作之後其型別變成了NSMallocBlock型別。

Block的型別	副本的配置儲存域	複製效果
NSStackBlock	棧	從棧複製到堆
NSGlobalStack	程式的資料區域	什麼也不做
NSMallocBlock	堆	引用計數增加

下面我們一起分析一下NSStackBlock型別的Block進行copy操作後Block物件從棧複製到了堆有什麼道理，我們首先來看一段程式碼：

void (^block)(void);

void test() {

int age = 10;

block = ^{

NSLog(@"age=%d", age);
};
}

int main(int argc, char * argv[]) {
@autoreleasepool {

test();

block();

return 0;
}
}

不出意外的話，列印結果應該是10，那麼結果是不是這樣呢？我們列印看一下：

age=-411258824

很奇怪，列印了一個這麼奇怪的數字。這是為什麼呢？

block使用了自動變數age，所以它是NSStackBlock型別的，因此block是存放在棧區，age是被捕獲作為結構體的成員變數，其值也是被儲存在棧區。所以當test這個函式呼叫完畢後，它棧上的東西就有可能被銷燬了，一旦銷燬了，age值就不確定是多少了。通過列印結果也可以看到，確實是影響到了block的執行。

如果我們對block執行copy操作，結果會不會不一樣呢？

void (^block)(void);

void test() {

int age = 10;

block = [^{

NSLog(@"age=%d", age);
} copy];
}

int main(int argc, char * argv[]) {
@autoreleasepool {

test();

block();

return 0;
}
}

列印結果：

age=10

這個時候得出了正確的輸出。

因為對block進行copy操作後，block從棧區被複制到了堆區，它的成員變數age也隨之被複制到了堆區，這樣test函式執行完之後，它的棧區被銷燬並不影響block，因此能得出正確的輸出。

7.ARC環境下自動為Block進行copy操作的情況

6中講的最後一個例子:

void (^block)(void);

void test() {

int age = 10;

block = ^{

NSLog(@"age=%d", age);
};
}

int main(int argc, char * argv[]) {
@autoreleasepool {

test();

block();

return 0;
}
}

這種使用方式其實非常常見，我們在使用的時候也沒有發現有什麼問題，那為什麼在MRC環境下就有問題呢？因為在ARC環境下編譯器為我們做了很多copy操作。其中有一個規則就是如果Block被強指標指著，那麼編譯器就會對其進行copy操作。我們看到這裡：

^{

NSLog(@"age=%d", age);
};

這個Block塊是被強指標指著，所以它會進行copy操作，由於其使用了自動變數，所以是棧區的Block。經過複製以後就到了堆區，這樣由於Block在堆區，所以就不受Block執行完成的影響，隨時可以獲取age的正確值。

總結一下ARC環境下自動進行copy操作的情況一共有以下幾種：

block作為函式返回值時。
將block賦值給__strong指標時。
block作為Cocoa API中方法名含有usingBlock的方法引數時。
GCD中的API。

block作為函式返回值時

typedef void(^PDBlock)(void);

PDBlock test() {

int age = 10;

return ^{

NSLog(@"age=%d", age);
};


}

int main(int argc, char * argv[]) {
@autoreleasepool {

PDBlock block = test();
block();

return 0;
}
}

test函式的返回值是一個block，那這種情況的時候，在棧區的

^{

NSLog(@"age=%d", age);
};

這個block會被複制到堆區

將block賦值給強指標時

7中第一個例子就是將block賦值給強指標時，進行了copy操作的情況。

block作為Cocoa API中方法名含有usingBlock的方法引數時

比如說遍歷陣列的函式：

NSArray *array = [[NSArray alloc] init];
[array enumerateObjectsUsingBlock:^(id_Nonnull obj, NSUInteger idx, BOOL * _Nonnull stop) {
NSLog(@"%d", idx);
}];

enumerateObjectsUsingBlock: 這個函式中的block會進行copy操作

GCD中的API

GCD中的很多API的引數都有block，這個時候都會對block進行一次copy操作，比如下面這個dispatch_after函式：

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{

NSLog(@"wait");
});