Jack_lin Cocoa开发者社区 3月30日
image
说起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);
|
|
|
image
Block与Block的变量
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结构体实例中。
Block中使用C语言数组
- 只使用C语言的字符串数组，也没有向捕获的局部变量赋值，然而下面的代码再编译时就会产生错误，如下所示：
|
|
|
int testBlock1(){ const char country[] = "China"; void (^block) (void) = ^{ printf("text=%c", country[1]); }; block(); return 0;}
编译的时候会出现错误:
image
错误信息
看到这，你会感到疑惑，上面刚讲到Block是如何截获局部变量的，为什么到这里就失效了呢？
这是因为，Block中，没有实现对C语言数组的截获。通过上述截获局部变量的理论，C语言数组会作为成员变量保存到Block实例的结构体中，在初始化Block时，由成员变量赋值给局部变量，猜测代码如下：
void func(char a[]){ char b[] = a;}
|
|
|
从而看出端倪，将C语言数组类型变量赋值给C语言数据类型变量，这个在C语言下是无法编译，C语言不允许这样编译的。
如何解决呢？
目前，可以改成C语言数组的形式就可以解决上述问题了。
|
1
2
3
4
5
6
7
8
9
10
|
int testBlock1(){
const char *country = "China";
void (^block) (void) = ^{
printf("text=%c", country[1]);
};
block();
return 0;
}
|
__block关键字的作用
前面的小节中，我们仅仅讲解了在Block中截获局部变量，那么，在Block中修改截获的局部变量又会带来什么样的问题呢？
image
修改截获的局部变量
通过上面的代码可以看出，虽然在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，写出更高质量的代码。
好久没有更新文章了，想必老铁们也都等着急了吧。主要是从2018年3月底更新后最后一篇文章，就一直在忙，关于那段时间的事情会在另一篇文章中详述。
谢谢大家的支持！
网友评论