深入理解Block
本文约5000字，大概阅读时间20分钟。
我用了将近一周的时间将与Block相关的知识点进行了整理，将相关内容整理成了脑图，分享给大家：
说起Block，我想大家再熟悉不过了。每天的开发过程中都在与他打着交道，简洁高效的使用给我们的工作带来了便利。
正是因为Block对于我们而言不可或缺，我更觉得应该抽出时间好好认识一下Block，了解一些他的优缺点、过往经历，让我们对它的理解更深一层，进而开发出更加高效的程序。
Block与C函数的区别和联系
Block是C语言的扩充，常被称为带有局部变量的匿名函数； 看一下正规的C语言函数定义：
int test(int count);
int result = test(10); 以上声明了函数名为test函数；
使用函数指针调用函数，如下所示：
int (*testFuncPtr)(int) = &test;
int result = (* testFuncPtr)(10); 对比Block，Block就可以定义为不带名称的函数，说的直白一点，就是匿名函数，即不用显式的定义函数名称，但是匿名函数都有固定的一个表达式。
^(int count){
printf("%d", count);
}
等价于：
void test(int count){
}Block语法定义格式如下：
^ 返回值类型 参数列表 表达式
省略之后：
^ 表达式通过上面的例子可以看出两点不同：
- 没有函数名称；
- 带有“^”符号；
Block的基本使用
可以通过定义Block类型的变量对Block进行调用,与函数指针有相似之处，具体如下：
int (^block)(int) = ^(int count){
return count + 1;
}
block(5);
Block类型变量用途：局部变量、参数、静态变量、全局变量以及静态全局变量等等。
Block 可以作为参数进行传递，也可以作为返回值进行传递,具体如下:
- (void)testFuncWithBlock:(void (^)(int count))block{
if (block) {
block(5);
}
}
// 将Block作为返回值，代码摘自·Masonry·
- (MASConstraint * (^)(id))equalTo {
return ^id(id attribute) {
return self.equalToWithRelation(attribute, NSLayoutRelationEqual);
};
} 具体以Masonry使用为例讲解一下，Block调用：
// Masonry 在常用布局时用到方法如下：
make.top.equalTo(self.titleLabel.mas_bottom).offset(15);
// 有些同学可能对上述的链式调用不是很清楚，其实上述链式调用就是使用Block实现的，分解如下：
MASConstraint *constraint = make.top;
MASConstraint *(^equalBlk)(id) = constraint.equalTo;
constraint = equalBlk(self.titleLabel.mas_bottom);
MASConstraint *(^offsetBlk)(CGFloat) = constraint.offset;
constraint = offsetBlk(15); 可使用关键字typedef,进行Block类型变量的定义
typedef int(^Blk)(int);
// 调用
Blk blk = ^int (int count){
return count ++;
};
int result = blk(5);Block 作为属性变量的用法：
@property (nonatomic, copy) void (^successCompletion)(int);
@property (nonatomic, copy) Blk failCompletion;通过上面一小节了解到:
- 函数与Block区别与联系；
- Block变量和Block表达式的联系
Block的实质
在前面小节中，介绍了Block的基本用法。那么问题来了，Block究竟是什么呢？现在公认的说法是带有自动变量的匿名函数，动手一探究竟。
使用Clang -rewrite-objc命令对下面代码进行编译:
void testBlock(){
int (^blk)(int) = ^(int count){
return count ++;
};
blk(5);
} 执行完命令会在同级目录下生成XX.cpp文件，这个文件就是编译好的文件。
由于编译后文件包含很多C函数声明，在此就不一一解释了，主要关注上述Block方法实现：
struct __block_impl {
void *isa;
int Flags;
int Reserved;
void *FuncPtr;
};
static struct __testBlock_block_desc_0 {
size_t reserved;
size_t Block_size;
} __testBlock_block_desc_0_DATA = { 0, sizeof(struct __testBlock_block_impl_0)};
struct __testBlock_block_impl_0 {
struct __block_impl impl;
struct __testBlock_block_desc_0* Desc;
__testBlock_block_impl_0(void *fp, struct __testBlock_block_desc_0 *desc, int flags=0) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;�
Desc = desc;
}
};
static int __testBlock_block_func_0(struct __testBlock_block_impl_0 *__cself, int count) {
return count ++;
}
函数具体的实现如下：
void testBlock(){
int (*blk)(int) = ((int (*)(int))&__testBlock_block_impl_0((void *)__testBlock_block_func_0, &__testBlock_block_desc_0_DATA));
((int (*)(__block_impl *, int))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk, 5);
} 虽然编译后Block方法很长，但是并不复杂，Block调用就像普通的C函数的使用。
首先，看一下源代码中Block方法体实现:
int (^blk)(int) = ^(int count){
return count ++;
};static int __testBlock_block_func_0(struct __testBlock_block_impl_0 *__cself, int count) {
return count ++;
} 可以发现两者在语法格式上非常相近，实际上Block所使用的匿名函数就是被作为简单的C函数处理的。
在代码中：
__testBlock_block_impl_0 *__cself 其中,参数__cself相当于C++中指向实例自身变量的this或者Objective-C中的self。参数__cself在这里是__testBlock_block_impl_0结构体的指针。
然后，看一下__testBlock_block_impl_0结构体的组成：
struct __testBlock_block_impl_0 {
struct __block_impl impl;
struct __testBlock_block_desc_0* Desc;
}; 去掉代码中加入的构造函数，感觉结构上清晰多了。第一个成员变量是impl,__block_impl结构体的声明如下所示：
struct __block_impl {
void *isa;
int Flags;
int Reserved;
void *FuncPtr;
};其中，有关对象isa指针的理解可以参考之前写过的文章Objective-C Runtime：深入理解类与对象
第二个成员变量Desc,主要保存block所在内存的区域以及Block的大小。
关于__testBlock_block_impl_0结构体构造函数如下：
__testBlock_block_impl_0(void *fp, struct __testBlock_block_desc_0 *desc, int flags=0) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;�
Desc = desc;
} isa指针指向_NSConcreteStackBlock, __testBlock_block_impl_0结构体相当于objc_object结构体的Objective-C类对象的结构体。
isa = &_NSConcreteStackBlock; 上述代码表明_NSConcreteStackBlock相当于objc_class结构体的实例。从而得知，Block就是Objective-C的对象了。
具体关于Objective-C类与对象的知识可以参考另一篇文章深入理解类与对象。
对于上述构造函数调用部分如下：
int (*blk)(int) = ((int (*)(int))&__testBlock_block_impl_0((void *)__testBlock_block_func_0, &__testBlock_block_desc_0_DATA));
((int (*)(__block_impl *, int))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk, 5);看着有些繁琐，对其去掉相关转换的部分：
struct __testBlock_block_impl_0 temp = __testBlock_block_impl_0(__testBlock_block_func_0, &__testBlock_block_desc_0_DATA);
struct __testBlock_block_impl_0 *blk = & temp;
(*blk->impl.FuncPtr)(blk, 5); 上述代码中，将__testBlock_block_impl_0结构体实例的指针赋值给变量blk,从而知道源代码中的Block表达式就是__testBlock_block_impl_0结构体类型的变量，同时也是该结构体在栈上生成的实例。
从函数指针调用得知，由Block语法转换的__testBlock_block_func_0函数指针被赋值到__testBlock_block_impl_0的成员变量FuncPtr，同时说明了__testBlock_block_func_0中的__cself指向Block值。
截获局部变量
在开发过程中，我们经常遇到在Block中截获局部变量或者改变局部变量，如下所示：
- (void)testBlock{
int value = 1;
void (^block) (void) = ^{
NSLog(@"value = %d", value);
};
block();
}看到这里，可能就有疑问了，Block内部是如何获取局部变量的，带着疑问重新Clang了一下源文件，似乎找到了答案，摘取了关键代码如下所示：
static void _I_TestBlock_testBlock(TestBlock * self, SEL _cmd) {
int value = 1;
void (*block) (void) = ((void (*)())&__TestBlock__testBlock_block_impl_0((void *)__TestBlock__testBlock_block_func_0, &__TestBlock__testBlock_block_desc_0_DATA, value));
((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
}
//Block内部实现：
static void __TestBlock__testBlock_block_func_0(struct __TestBlock__testBlock_block_impl_0 *__cself) {
int value = __cself->value; // bound by copy
NSLog((NSString *)&__NSConstantStringImpl__var_folders_pf_nyb_8kl12yq6v2sxzwdr5v8w0000gn_T_TestBlock_516a43_mi_0, value);
}
// Block结构体
struct __TestBlock__testBlock_block_impl_0 {
struct __block_impl impl;
struct __TestBlock__testBlock_block_desc_0* Desc;
// 将局部变量追加成成员变量
int value;
__TestBlock__testBlock_block_impl_0(void *fp, struct __TestBlock__testBlock_block_desc_0 *desc, int _value, int flags=0) : value(_value) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
通过上述Block语法表达式中使用的局部变量作为成员变量被加到了__TestBlock__testBlock_block_impl_0结构体中，同时，加到结构体中的成员变量的类型与局部变量的类型保持一致。当然了，如果Block表达式中没有使用局部变量，则不会加入到Block的结构体中。
通过初始化Block实例的构造方法和调用也可以看到局部变量value作为参数传递，具体如下所示：
//Block 初始化方法
__testBlock_block_impl_0(void *fp, struct __testBlock_block_desc_0 *desc, int _value, int flags=0) : value(_value)
// 初始化方法的调用：
void (*block) (void) = ((void (*)())&__testBlock_block_impl_0((void *)__testBlock_block_func_0, &__testBlock_block_desc_0_DATA, value));到这里，大致明白了Block如何截获局部变量value的，小结如下：
- 1、系统编译时，根据Block是否需要截获外部变量来判断是都将局部变量作为成员变量保存到Block的结构体
__testBlock_block_impl_0中； - 2、若需要截获局部变量，需要在初始化结构体函数中添加与局部变量相同类型的参数；
- 3、局部变量就通过初始化构造函数传递到Block结构体
__testBlock_block_impl_0，同时赋值给Block中的成员变量； - 4、在执行Block时，局部变量
value会初始化__testBlock_block_impl_0结构体实例， 如下所示；
impl.isa = &_NSConcreteStackBlock;
impl.Flags = 0;
impl.FuncPtr = __testBlock_block_func_0;
Desc = &__testBlock_block_desc_0_DATA;
value = 1;Block中使用C语言数组
只使用C语言的字符串数组，也没有向捕获的局部变量赋值，然而下面的代码再编译时就会产生错误，如下所示
int testBlock1(){
const char country[] = "China";
void (^block) (void) = ^{
printf("text=%c", country[1]);
};
block();
return 0;
}编译的时候会出现错误:
看到这，你会感到疑惑，上面刚讲到Block是如何截获局部变量的，为什么到这里就失效了呢？
这是因为，Block中，没有实现对C语言数组的截获。通过上述截获局部变量的理论，C语言数组会作为成员变量保存到Block实例的结构体中，在初始化Block时，由成员变量赋值给局部变量，猜测代码如下：
void func(char a[]){
char b[] = a;
}从而看出端倪，将C语言数组类型变量赋值给C语言数据类型变量，这个在C语言下是无法编译，C语言不允许这样编译的。
如何解决呢？ 目前，可以改成C语言数组的形式就可以解决上述问题了。
int testBlock1(){
const char *country = "China";
void (^block) (void) = ^{
printf("text=%c", country[1]);
};
block();
return 0;
}__block关键字的作用
前面的小节中，我们仅仅讲解了在Block中截获局部变量，那么，在Block中修改截获的局部变量又会带来什么样的问题呢？
通过上面的代码可以看出，虽然在Block中不能对局部变量进行修改，但是在全局变量、静态全局变量、静态变量都是可以在Block中进行修改的，具体如下：
int globalValue = 10;
static int staticGlobalValue = 5;
- (void)testBlockFunc {
static int value = 5;
void (^block)(void) = ^{
globalValue = 11;
staticGlobalValue = 12;
value = 3;
printf("globalValue = %d \n staticGlobalValue = %d \n value = %d \n", globalValue, staticGlobalValue, value);
};
block();
}打印的结果如下：
2018-12-02 21:56:47.323727+0800 TestBlock[38880:1182883]
globalValue = 11
staticGlobalValue = 12
value = 3再次使用clang编译了一下，发现静态全局变量和全局变量转换前后没有任何变换，大家可能疑问静态局部变量是如何转换的呢？
__TestBlockMemory__testBlockFunc_block_impl_0 *__cself) {
int *value = __cself->value; // bound by copy
globalValue = 11;
staticGlobalValue = 12;
(*value) = 3;
printf("globalValue = %d \n staticGlobalValue = %d \n value = %d \n", globalValue, staticGlobalValue, (*value));
}与截获局部变量的转换很相似，唯一的区别是Int类型的变量转换成了指针，从而正确的改变了原有的值。
除了上述的几种方式可以在Block中修改变量值外，OC专门提供了一个说明符——__block。
int testBlock(){
__block int number = 1;
void (^block) (void) = ^{
number = 2;
};
block();
return 0;
}将上述代码进行Clang编译，还原成以下代码:
struct __Block_byref_number_0 {
void *__isa;
__Block_byref_number_0 *__forwarding;
int __flags;
int __size;
int number;
};
struct __testBlock_block_impl_0 {
struct __block_impl impl;
struct __testBlock_block_desc_0* Desc;
__Block_byref_number_0 *number; // by ref
__testBlock_block_impl_0(void *fp, struct __testBlock_block_desc_0 *desc, __Block_byref_number_0 *_number, int flags=0) : number(_number->__forwarding) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
static void __testBlock_block_func_0(struct __testBlock_block_impl_0 *__cself) {
__Block_byref_number_0 *number = __cself->number; // bound by ref
(number->__forwarding->number) = 2;
}惊奇的发现，局部变量number变成了结构体__Block_byref_number_0，Block的__testBlock_block_impl_0的结构体实例持有__block变量的__Block_byref_number_0结构体实例的指针。
__testBlock_block_impl_0实例的成员变量__forwarding指向实例自身，并通过__forwarding变量访问成员变量number。
__Block_byref_number_0 *number = __cself->number; // bound by ref
(number->__forwarding->number) = 2;值得注意一点是，__Block_byref_number_0结构体并没有在__testBlock_block_impl_0结构体中，这样主要是为了在多个Block中共用该__block变量。
Block的储存
Block分为三类： _NSConcreteStackBlock
种类 | 存储域 | Block变量类型 | 复制后的存储域 |
|---|---|---|---|
_NSConcreteStackBlock | 栈 | 局部/自动变量 | 由栈复制到堆上 |
_NSConcreteGlobalBlock | 程序的数据区域(.data区) | 全局变量 | 保持在数据区 |
_NSConcreteMallocBlock | 堆 | 局部变量 | 增加引用计数 |
定义在全局的Block在变量作用域之外通过指针访问使用，定义在栈上的__block局部变量和Block在超出作用域时将被废弃。那Block超出作用域是如何存在的呢？
这里就用到Block的Copy操作，即将分配在栈上的Block 和__block变量复制到堆上，从而延长了Block和__block变量的生命周期。
那么，Block被复制到堆上的操作是何时进行的呢？
首先，比较明确的一点是：将Block作为返回值返回时，编译器将会自动将Block由栈上复制到堆上，其他情况下，需要手动执行Copy操作；在ARC有效的情况下，Block是否被复制到堆上，编译器会进行相关的判断；
举个栗子：
typedef int (^BlockCase)(int);
BlockCase getBlockCallBack(int value) {
return ^(int count) {
return count + value;
};
}在ARC有效的情况下，作为返回值的Block会被复制到堆上。当然了，系统中存在的一些API是无需手动复制的：Cocoa框架方法中带有usingBlock方法、GCD相关的API等等。
__block变量的存储域
当在Block中使用__block变量时，当在Block从栈复制到堆上同时，被使用过的__block变量也会从栈复制到堆上。如下图所示：
__block变量所分配的存储域 | Block从栈复制到堆上后的影响 |
|---|---|
栈 | 由栈复制到堆上并被Block持有 |
堆 | 被Block持有 |
__fawarding指针存在的意义
前边介绍了Block和__block变量从栈复制到堆上的情景，但都与__fawarding指针脱不开关系。
- 由栈复制到堆之前，__fawarding指针指向自身；
- 复制之后，栈上的__fawarding指针指向复制到堆上的__block变量，堆上的__fawarding指针指向自身。
- 从而，解释了无论__block变量配置在栈上还是配置在堆上时都能正确的访问到__block变量；
Block截获对象
通过了解上节的内容，很好理解以下内容：
- __block修饰的变量从栈复制到堆上，赋值给该__block变量的对象也被从栈复制到堆上，当__block变量从堆上释放时，该对象才能得到释放；
- 当使用__weak修饰的__block变量在赋值的时候，由于赋值对象的作用域问题而释放，从而导致__block变量不能强持有该对象。
Block循环引用
形成原因：
- 对象与Block相互持有；
- 形成强持有环； 解决方式：
- 设置weak弱持有关系；
- 手动置为nil，梳理好持有关系，破坏环状结构。
结束
关于Block就大致说到这吧，从Block的使用到Block的原理剖析，希望能让我们更客观的认识Block，写出更高质量的代码。
预祝各位老铁少写Bug！！