在OC语言中，一共有3中类型的block：
- _NSConcreteGlobalBlock，全局的静态block，不会访问任何外部变量
- _NSConcreteStackBlock，保存在栈中的block，当函数返回时会被销毁
- _NSConcreteMallocBlock，保存在堆中的block，当引用计数为0时会被销毁
1、用clang分析block实现
clang提供了一个命令，可以将OC的源码改写成C语言，借此可以研究block具体的源码实现方式：
clang -rewrite-objc block.c
1.1 NSConcreteGlobalBlock
创建文件block1.c，实例代码如下：
//block1.c
#include <stdio.h>
int main (){
^{printf("Hello, World!\n");}();
return 0;
}
解析命令：clang -rewrite-objc block1.c即可在当前目录创建一个名为block1.cpp的文件：
image.png
struct __block_impl {
void *isa;//block的isa指针
int Flags;
int Reserved;
void *FuncPtr;//函数指针
};
struct __main_block_impl_0 {
//block的实现
struct __block_impl impl;//FuncPtr保存函数指针，所以impl是实际的函数指针
struct __main_block_desc_0* Desc;//block的附加信息，包括结构体的大小，需要capture和dispose的变量列表等
//构造函数
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int flags=0) {
impl.isa = &_NSConcreteStackBlock;
//未开启arc，开启arc时，block应该是_NSConcreteGlobalBlock
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
printf("Hello, World!\n");
}
static struct __main_block_desc_0 {
size_t reserved;
size_t Block_size;//保存结构体的大小。每个block会capture一些变量，这些变量会加到结构体__main_block_impl_0中，使其体积变大。
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0)};
int main (){
((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA))();
//函数_main_block_func_0，block中impl中保存了其地址(指针)
return 0;
}
开启arc时，block应该是_NSConcreteGlobalBlock！！！
1.2 NSConcreteStackBlock
我们另外新建一个名为"block2.c"的文件：
#include <stdio.h>
int main (){
int a = 100;
void (^block2)(void) = ^{
printf("%d\n",a);
};
block2();
return 0;
}
转换后的关键代码如下：
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
int a; //block中定义了同名变量，用来保存外部传入的变量。所以，在block内部修改变量a，不会影响外部的实际变量a
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _a, int flags=0) : a(_a) {//给block中同名变量赋值
impl.isa = &_NSConcreteStackBlock;//分配在栈上的实例
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
//实际执行的函数，block保存了函数的地址(指针)
int a = __cself->a; // bound by copy
printf("%d\n",a);
}
static struct __main_block_desc_0 {
size_t reserved;
size_t Block_size;//多了一个变量a，结构体变大了
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0)};
int main (){
int a = 100;
void (*block2)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, a));
//将外部的变量a作为形参传入
((void (*)(__block_impl *))((__block_impl *)block2)->FuncPtr)((__block_impl *)block2);
return 0;
}
我们修改上面的源码，在变量前面增加__block关键字：
#include <stdio.h>
int main (){
__block int i = 1024;
void (^block3)(void) = ^{
printf("%d\n",i);
i = 1023;
};
block3();
return 0;
}
生成的关键代码如下，与之前的差异还是比较大的：
//新增了一个结构体，用来保存我们要capture并且修改的变量i
struct __Block_byref_i_0 {
void *__isa; //带有isa，说明它也是一个变量
__Block_byref_i_0 *__forwarding; //指向外部的变量
int __flags;
int __size;
int I;
};
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
__Block_byref_i_0 *i; // 引用了__Block_byref_i_0指针，可以起到修改外部变量的作用
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_i_0 *_i, int flags=0) : i(_i->__forwarding) {//外部变量赋值给内部变量的__forwarding指针，这样可以通过修改__forwarding来修改外部变量
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
__Block_byref_i_0 *i = __cself->i; // bound by ref
printf("%d\n",(i->__forwarding->i));
(i->__forwarding->i) = 1023; //通过__forwarding指针，修改外部的变量
}
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {_Block_object_assign((void*)&dst->i, (void*)src->i, 8/*BLOCK_FIELD_IS_BYREF*/);}//修改内部变量i的引用计数
static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->i, 8/*BLOCK_FIELD_IS_BYREF*/);}//修改内部变量i的引用计数
static struct __main_block_desc_0 {
size_t reserved;
size_t Block_size;
//block需要负责__Block_byref_i_0结构体相关的内存管理，所以__main_block_desc_0中增加了copy和dispose函数指针，用于在调用前后修改响应变量的引用计数
void (*copy)(struct __main_block_impl_0*, struct __main_block_impl_0*);
void (*dispose)(struct __main_block_impl_0*);
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0), __main_block_copy_0, __main_block_dispose_0};
int main (){
__attribute__((__blocks__(byref))) __Block_byref_i_0 i = {(void*)0,(__Block_byref_i_0 *)&i, 0, sizeof(__Block_byref_i_0), 1024};
//(__Block_byref_i_0 *)&I，传入的是外部变量的指针
void (*block3)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_i_0 *)&i, 570425344));
((void (*)(__block_impl *))((__block_impl *)block3)->FuncPtr)((__block_impl *)block3);
return 0;
}
1.3 NSConcreteMallocBlock
NSConcreteMallocBlock类型的block通常不会在源码中直接出现，只有当一个block被调用其copy方法的时候，系统才会将这个block复制到堆中，从而产生NSConcreteMallocBlock类型的block。
stack
malloc
NSConcreteMallocBlock会持有对象：
- (void)viewDidLoad {
[super viewDidLoad];
NSObject *object = [[NSObject alloc] init];
NSLog(@"最初的引用计数%lu", object.retainCount);
void(^block)(void) = Block_copy(^(){
NSLog(@"在block中的引用计数%lu",object.retainCount);
});
NSLog(@"block的类型%@",block);
block();
NSLog(@"执行后的引用计数%lu",object.retainCount);
Block_release(block);
NSLog(@"释放后的引用计数%lu",object.retainCount);
}
需要设置上述文件支持mrc：
image.png
在arc下直接打印引用计数：
CFGetRetainCount((__bridge CFTypeRef)(obj)))上述代码段打印结果如下：
image.png
当我们不使用Block_copy，即：
void(^block)(void) =^(){
NSLog(@"在block中的引用计数%lu",object.retainCount);
};
image.png
由上可知：只要这个NSConcreteMallocBlock存在，内部对象的引用计数就会+1。
block.h
image.png
扩展：block_copy
2、block内部数据结构
上述的block源码都是基于clang编译器转换后的代码，而从苹果的llvm项目的开源代码中，我们可以看到block的数据结构定义：
blockRuntime
block
对应的结构体定义如下：
struct Block_descriptor {
unsigned long int reserved;
unsigned long int size;
void (*copy)(void *dst, void *src);
void (*dispose)(void *);
};
struct Block_layout {
void *isa;
int flags;
int reserved;
void (*invoke)(void *, ...);
struct Block_descriptor *descriptor;
/* Imported variables. */
};
一个block实例实际上由6部分构成：
- isa指针，所有对象都有该指针，用于实现对象相关的功能
- flags，用于按bit位表示一些block的附加信息
- reserved，保留变量
- invoke，函数指针，指向具体的block实现的函数调用地址，相当于clang编译器下的impl，命名不一样而已！
- descriptor，表示该block的附加描述信息，主要是size大小，以及copy和dispose函数的指针
- variables，capture过来的变量，block能够访问它外部的局部变量，就是因为将这些变量(或变量的地址)复制到了结构体中
该数据结构和clang分析出来的结构实际上是一样的，仅仅是结构体的嵌套方式不一样。比如，下面两个结构体的嵌套方式不一样，但是在内存上是完全一样的，原因是结构体本身并不带有任何额外的附加信息：
struct SampleA {
int a;
int b;
int c;
};
struct SampleB{
int a;
struct Part1 {
int b;
};
struct Part2{
int c;
};
}
3、注意事项
3.1 避免循环引用
由于block会复制外部的变量，所以如果不注意，会比较容易造成循环引用：
UIViewController *__weak weakSelf = self;
self.contentView.selectedBlock = ^(UITableView *tableView, NSIndexPath *indexPath){
[weakSelf someMethod];
};
3.2 ARC对block类型的影响
在ARC开启的情况下，将只会有NSConcreteGlobalBlock和NSConcreteMallocBlock类型的block，原本的NSConcreteStackBlock的block会被NSConcreteMallocBlock类型的block替代，在苹果的官方文档中也提到，当把栈中的block返回时，就不需要调用copy方法了：
int i = 1024;
NSLog(@"%@",^{//直接打印stack
NSLog(@"%d\n", i);
});
void (^block1)(void) = ^{//创建后返回，malloc
NSLog(@"%d\n", i);
};
// block1();
NSLog(@"%@", block1);
打印结果如下：
image.png
