Block是什么？
在oc中它是带有^符号的匿名函数，遵循BN范式: ^ 返回值类型 参数列表 表达式 （参数和返回值为空的时候可以省略）。
而在C中（OC编译后的C）它会被编译成一堆结构体和几个函数以及静态变量。
而这几个结构体和函数，正是Block实现的本质.
- Block 结构体
- 表达式转换成的函数
- 描述体
- Block主体结构体
- Block的调用
// Block 结构体
struct __block_imp1 {
void *isa;
int Flags;
int Reserved;
void *FuncPtr;
}
// 描述体
static struct __main_block_desc_0 {
unsigned long reserved;
unsigned long Block_size;
} __main_block_desc_0_DATA = {
0,
sizeof(struct __main_block_imp1_0)
}
// Block主体结构体
struct __main_block_imp1_0 {
struct __block_imp1 imp1;
struct __main_block_desc_0* Desc;
__main_block_imp1_0(void *fp, struct __main_block_desc_0 *desc, int flags=0) {
imp1.isa = &_NSConcreteStackBlock;
imp1.Flags = flags;
imp1.FuncPtr = fp;
Desc = desc;
}
}
// 表达式转换成的函数
static void __main_block_func_0(struct __main_block_imp1_0 *__cself) {
printf("this is a block");
}
int main() {
// Block的调用
void (*blk)(void) = (void(*)(void))&__main_block_imp1_0((void*)__main_block_func_0,&__main_block_desc_0_DATA);
((void(*)(struct __block_imp1 *))((struct __block_imp1 *)blk)->FuncPtr)((struct __block_imp1 *)blk);
return 0;
}
逐一来分析一下，这几个结构体的作用。
// Block 结构体
struct __block_imp1 {
void *isa;
int Flags;
int Reserved;
void *FuncPtr;
}
由于转化后的Block类型结构体的成员中有isa指针，不难得知它和某些OC的类有关系，而在struct __main_block_imp1_0的初始化函数中，isa被赋予了一个_NSConcreteStackBlock的类。这表明该Block属于stack存在于栈中的类。
_NSConcreteStackBlock 存在于栈中
_NSConcreteMallocBlock 存在于堆中
_NSConcreteGlobalBlock 存在于.Data（程序的数据区域）中
// 描述体
static struct __main_block_desc_0 {
unsigned long reserved;
unsigned long Block_size;
} __main_block_desc_0_DATA = {
0,
sizeof(struct __main_block_imp1_0)
}
只是存储了一些升级区域和结构大小。
// Block主体结构体
struct __main_block_imp1_0 {
struct __block_imp1 imp1;
struct __main_block_desc_0* Desc;
__main_block_imp1_0(void *fp, struct __main_block_desc_0 *desc, int flags=0) {
imp1.isa = &_NSConcreteStackBlock;
imp1.Flags = flags;
imp1.FuncPtr = fp;
Desc = desc;
}
}
__main_block_imp1_0结构体从某种程度上封装了前两个结构体，但它的实际意义不止于此。
// 表达式转换成的函数
static void __main_block_func_0(struct __main_block_imp1_0 *__cself) {
printf("this is a block");
}
int main() {
// Block的调用
void (*blk)(void) = (void(*)(void))&__main_block_imp1_0((void*)__main_block_func_0,&__main_block_desc_0_DATA);
((void(*)(struct __block_imp1 *))((struct __block_imp1 *)blk)->FuncPtr)((struct __block_imp1 *)blk);
return 0;
}
函数和调用很简单，就是一些类型转换容易让人眼花缭乱，经过删繁就简之后，就是简单的函数声明和调用而已。
需要注意的是，__main_block_func_0是以__main_block_imp1_0这个主体结构体入参的，这在变量捕捉的时候有很大作用。
变量捕捉
熟悉了Block的本质之后，就是对于Block的运用了，Block为什么如此好用的原因之一就在于，我们可以做到一般函数不能做到的事情，例如：局部变量的捕捉。
int main() {
int v = 1;
void (^blk)(void) = ^{
printf("this is a block %d",v);
};
blk();
return 0;
}
可以看到，变量v能够在表达式内部获取到。
然而当我们想要在内部改变这个变量的值的时候，会得到一个编译错误。
int main() {
int v = 1;
void (^blk)(void) = ^{
printf("this is a block %d",v);
v = 2; // error: Variable is not assignable (missing __block type specifier)
};
blk();
return 0;
}
为什么？
既然错误发生在表达式内，我们就来分析一下编译后的函数static void __main_block_func_0(struct __main_block_imp1_0 *__cself) 捕获变量后，这个函数的实现变成了这样：
// 表达式转换成的函数
static void __main_block_func_0(struct __main_block_imp1_0 *__cself) {
int v = __cself->v;
printf("this is a block %d",v);
}
入参__main_block_imp1_0多了个v的成员变量。
也就是说，编译后，__main_block_imp1_0结构体负责存储捕获的局部变量。
然而捕获的变量也是Int类型的，并非指针，所以我们在__main_block_func_0中改变变量V的值是没有任何意义的。编译器很聪明的检测到了这个操作。
那么我们加入__block之后呢？
int main() {
__block int v = 1;
void (^blk)(void) = ^{
printf("this is a block %d",v);
v = 2;
};
blk();
return 0;
}
编译器的报错消失了。
意味着我们可以随意在block内改动v这个局部变量了。
那么内部是怎么实现的呢？
还是看函数实现:
// 表达式转换成的函数
static void __main_block_func_0(struct __main_block_imp1_0 *__cself) {
__Block_byref_val_0 *val = __cself->val;
printf("this is a block %d",(val->_forwarding->v));
(val->_forwarding->v) = 2;
}
__main_block_imp1_0里存储的成员V变了，不再是简单的Int类型，而是变成了
__Block_byref_val_0 指针。
struct __Block_byref_val_0 {
void *__isa;
__Block_byref_val_0 *__forwarding;
int __flags;
int __size;
int __v;
}
需要稍微分析一下，这几个成员变量的意义。
找到它初始化的地方，在main函数内：
__Block_byref_val_0 v = (
0,
&v,
0,
sizeof(__Block_byref_val_0),
1
)
isa 被赋值为空
_forwarding 指向了自己，
flags =0
size 传入了大小
v 赋值成捕获的变量的值
而原本的int变量v消失了，__Block_byref_val_0变量v取而代之，将此结构体的指针赋值给
__main_block_imp1_0成员变量后，就可以实现对变量v的修改了。
这是__block的作用，可是在结构体
__Block_byref_val_0初始化的时候还有一个有趣的地方，就是：
__Block_byref_val_0 *__forwarding;
__forwarding指针有什么意义呢？它指向了自己，并且在函数体内修改存储值时，也访问了"自己"。为何要多此一举？
Block的存储域
再弄清__forwarding指针的作用之前，我们先要缕清楚这三种Block的区别以及应用的场景。
| 类型 | 内存分布 | 场景 |
|---|---|---|
| _NSConcreteStackBlock | 存在于栈中 | 定义在函数内部，未被强引用，且捕获了外部变量。 |
| _NSConcreteMallocBlock | 存在于堆中 | 被强引用，由_NSConcreteStackBlock被拷贝到堆内存。 |
| _NSConcreteGlobalBlock | 存在于.Data（程序的数据区域）中 | 定义在全局区域，或者未捕获外部变量且定义在函数内部的block |
从内存管理的角度看，_NSConcreteGlobalBlock类型的Block讨论意义不大。
_NSConcreteStackBlock和 _NSConcreteMallocBlock 才是我们要讨论的重点。
假定这样一种情况(MRC下)：
blk_t blk;
{
NSAutoreleasePool *pool = [NSAutoreleasePool new];
id array = [[[NSMutableArray alloc] init] autorelease];
blk = ^( id obj){
[array addObject:obj];
NSLog(@"count is %d",[array count]);
};
[pool release];
}
blk([[NSObject alloc] init]);
blk([[NSObject alloc] init]);
blk([[NSObject alloc] init]);
由于是MRC环境，加入NSAutoreleasePool来模拟array的释放周期。
可以看到，在大括号以外调用block，肯定会崩溃，因为array已经释放了。并且在这种情况下，Block属于_NSConcreteStackBlock类型。
我们稍稍改动一下：
blk_t blk;
{
NSAutoreleasePool *pool = [NSAutoreleasePool new];
id array = [[[NSMutableArray alloc] init] autorelease];
blk = [^( id obj){
[array addObject:obj];
NSLog(@"count is %d",[array count]);
} copy];
[pool release];
}
blk([[NSObject alloc] init]);
blk([[NSObject alloc] init]);
blk([[NSObject alloc] init]);
程序输出正常了，array也被block正常捕获。
而Block的类型经过copy之后，变成了_NSConcreteMallocBlock，copy方法实际调用的是：
id objc_retainBlock(id x) {
return (id)_Block_copy(x);
}
_Block_copy 作用按照文档上来说是将Block拷贝到堆内存——这和我们的测试结果一样。
随着Block被复制到堆内存之后，Block所持有的__block变量也会复制到堆内存并且持有，要证明需要看编译后的代码：
static void __main_block_copy_0 (struct __main_block_imp1_0*dst ,struct __main_block_imp1_0*src){
_Block_object_assign(&dst->val, src->val, BLOCK_FIELD_IS_BYREF);
}
static void __main_block_dispose_0(struct __main_block_imp1_0*scr){
_Block_object_dispose(src->val, BLOCK_FIELD_IS_BYREF);
}
这两个方法是在Block被复制到堆内存和从堆内存释放的时候调用的。
_Block_object_assign 和 _Block_object_dispose分别是Block持有变量的赋值和释放。
__forwarding指针：
这时候我们可以来解释这个指针的作用了：
__block int v = 1;
void (^blk)(void) = [^{v++;} copy];
v++;
blk();
printf("num is %d",v);
可以看到经过copy后的变量v在外部仍然可以改变，试想如果没有__forwarding指针存在的话，v经过编译后，结构体仍然存在于栈上，此时改变v的值结果肯定不是我们想要的3。
__forwarding保证__Block的变量在赋值时使得位于栈上的结构体内的__forwarding指针指向堆内的Block，从内访问同一个且正确的变量。
