1. Block 本质
现在我们来实现一个最简单的BlockA
void (^BlockA)(void) = ^{
NSLog(@"block A");
};
BlockA();
通过clang命名转化成C++源码：
xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc -fobjc-arc -fobjc-runtime=ios-8.0.0 main.m
查看源码会得到 BlockA 会生成以下几个结构体：
// 函数栈里面定义的 BlockA
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 的第一个结构体成员
// 里面包含有 isa 指针
struct __block_impl {
void *isa;
int Flags;
int Reserved;
void *FuncPtr;
};
// 里面有个主要的变量 Block_size ，通过sizeof(struct __main_block_impl_0)赋值，实际上是BlockA的内存大小
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)};
// blockA {} 花括号里面的代码，需要传递 __main_block_impl_0 参数
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
NSLog((NSString *)&__NSConstantStringImpl__var_folders_50_s42jfyxs01s8t4z0c1q2p2c00000gn_T_main_d4d224_mi_1);
}
根据BlockA的定义可以看出，Block和对象一样拥有isa指针，且有Block_size来计算分配内存空间的大小的属性，所以Block也是一个对象，对象就能调用Class方法（通过block能够调用Class方法也能反推block是一个对象）。
接下来看 BlockA(); 转化成的源码
void (*BlockA)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));
// 初始化BlockA，传入 __main_block_func_0 执行的函数地址，
// 通过 __main_block_impl_0 构造函数可知 __main_block_func_0 会通过 impl.FuncPtr = fp; 赋值给 FuncPtr
// BlockA() 源码
((void (*)(__block_impl *))((__block_impl *)BlockA)->FuncPtr)((__block_impl *)BlockA);
// 去掉强制类型转换
BlockA->FuncPtr(BlockA);
// 其实BlockA()就是通过函数指针直接调用了函数并且传入了BlockA对象
所以Block可以简单总结：
- block本质上也是一个OC对象，它内部也有个isa指针;
- block是封装了函数调用以及函数调用环境的OC对象.
由上可得Block的内存结构图如下：
2，Block类型
Block 有三种类型：
1，NSGlobalBlock 全局区的Block
2，NSStackBlock 栈区的Block
3，NSMallocBlock 堆区的Block
接下来我们通过定义几个Block来访问外部变量，看看他们有什么区别：
int G = 100;
// 全局区的block
void (^Block_G)(void) = ^{
NSLog(@"block G %d", G);
};
int main(int argc, const char * argv[]) {
@autoreleasepool {
// 不访问任何变量
void (^BlockA)(void) = ^{
NSLog(@"block A");
};
BlockA();
// 访问auto 局部变量
int b = 10;
void (^BlockB)(void) = ^{
NSLog(@"block B %d", b);
};
b = 20;
BlockB();
// weak block，让编译器不进行 copy 操作
__weak void (^BlockC)(void) = ^{
NSLog(@"block D %d", b);
};
BlockC();
static int d = 25;
// 访问全局变量
void (^BlockD)(void) = ^{
NSLog(@"block D %d", d);
};
d = 30;
BlockD();
NSLog(@"BlockA class -> %@", [BlockA class]);
NSLog(@"BlockB class -> %@", [BlockB class]);
NSLog(@"BlockC class -> %@", [BlockC class]);
NSLog(@"BlockD class -> %@", [BlockD class]);
NSLog(@"BlockG class -> %@", [Block_G class]);
}
return 0;
}
打印结果【注arc模式下】：
根据以上输出我们带着几个疑问来探寻下Block的实现原理：
1，为什么Block能调用class方法？
2，b，d变量被修改后，为什么Block B里面的输出值不是20？而BlockD输出的是30
3，同样在main函数里面定义的BlockA/B/C，为什么Class类型不一样？
4，同样是NSGlobalBlock类型的Block_G与BlockA定义是一样的吗？
通过前面讲的，我们知道了 BlockA的内存结构，接下来我们看下 BlockB 和BlockD的内存结构：
/* OC代码
// 访问局部变量
void (^BlockB)(void) = ^{
NSLog(@"block B %d", b);
};
*/
// BlockB 定义
struct __main_block_impl_1 {
struct __block_impl impl;
struct __main_block_desc_1* Desc;
int b;
__main_block_impl_1(void *fp, struct __main_block_desc_1 *desc, int _b, int flags=0) : b(_b) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
/* OC代码
static int d = 30;
// 访问全局变量
void (^BlockD)(void) = ^{
NSLog(@"block D %d", d);
};
*/
// BlockD 源码定义
struct __main_block_impl_3 {
struct __block_impl impl;
struct __main_block_desc_3* Desc;
int *d;
__main_block_impl_3(void *fp, struct __main_block_desc_3 *desc, int *_d, int flags=0) : d(_d) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
从上面BlockB和BlockD的内存结构可以看出，他们比BlockA内部多一个变量，多出来的变量其实Block捕获外部的变量，捕获的变量可以得出：
- BlockB 里面捕获的是int b 是一个值类型的int变量，所以后面b值修改后，BlockB里面的b不会变；
- BlockD 里面捕获的是int *d 是一个指针变量，所以后面d值修改后，BlockD通过指针访问的d还是BlockD外面的变量d。
以下是Block捕获变量的规则：
再来看下Block_G 的定义如下：
struct __Block_G_block_impl_0 {
struct __block_impl impl;
struct __Block_G_block_desc_0* Desc;
__Block_G_block_impl_0(void *fp, struct __Block_G_block_desc_0 *desc, int flags=0) {
impl.isa = &_NSConcreteGlobalBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
BlockA 和 Block_G 的区别是 isa 指针定义类型不一样
BlockA：_NSConcreteStackBlock 在函数栈里面定义的block
Block_G：_NSConcreteGlobalBlock 在全局区定义的block
其实在Clang的文档中，只定义了两个Block类型: _NSConcreteGlobalBlock 和 _NSConcreteStackBlock 。而在Console中的Log我们看到的3个类型应该是处理过的显示，这些字样在苹果的文档和Clang/LLVM的文档中实难找到。
Console中输出的的class类型是根据访问外部变量来确定的，其规则如下：
根据Block类型及捕获变量规则我们就能知道为什么BlockA/B/C的类型为什么不一样了：
- BlockA没有访问任何变量，所以它是NSGlobalBlock类型
- BlockC访问了局部auto变量，所以它是NSStackBlock类型
- BlockB访问了局部auto变量，arc自动给他进行了copy操作，所以它是NSMallocBlock类型
在ARC环境下，编译器会根据情况自动将栈上的block复制到堆上，比如以下情况：
- block作为函数返回值时
- 将block赋值给__strong指针时
- block作为Cocoa API中方法名含有usingBlock的方法参数时
- block作为GCD API的方法参数时
MRC下block属性的建议写法
@property (copy, nonatomic) void (^block)(void);
ARC下block属性的建议写法，ARC下stong和copy没有区别
@property (strong, nonatomic) void (^block)(void);
@property (copy, nonatomic) void (^block)(void);
3，Block内存管理
Block访问对象
FRFruit *fruit = [[FRFruit alloc] init];
FRFruit *fruit1 = [[FRFruit alloc] init];
__weak FRFruit *weakfruit = fruit1;
void (^Block_Objct)(void) = ^{
NSLog(@"block %@", fruit);
NSLog(@"block %@", weakfruit);
};
Block_Objct();
转化成C++源码
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
FRFruit *__strong fruit;
FRFruit *__weak weakfruit;
....
};
static struct __main_block_desc_0 {
size_t reserved;
size_t Block_size;
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};
可以看出Block里面默认捕获外面的对象为strong属性修饰，如果外部是weak属性的，其内部也会是相应的weak属性修饰；
__main_block_desc_0 结构体里面多了copy和dispose两个函数，它们是Block用来管理内存的
来看下它们的定义：
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {
_Block_object_assign((void*)&dst->fruit, (void*)src->fruit, 3);
_Block_object_assign((void*)&dst->weakfruit, (void*)src->weakfruit, 3);
}
static void __main_block_dispose_0(struct __main_block_impl_0*src) {
_Block_object_dispose((void*)src->fruit, 3);
_Block_object_dispose((void*)src->weakfruit, 3)
;}
里面主要有 _Block_object_assign() 和 _Block_object_dispose() 两个函数
- 当block被copy到堆时；
·会调用block内部的copy函数；
·copy函数内部会调用 Block_object_assign 函数；
·Block_object_assign 当传入的参数是stong类型时会进行retain操作，如果是weak指针不会进行retain操作；- main_block_dispose_0 方法类似C++里面对析构函数，Block释放时会调用，Block_object_dispose 函数则是对传入参数进行release释放。
所以当block对象未释放时，它里面如果是strong修饰的对象也不会被释放，正因为如此，所以Block常常伴随着会出现循环引用问题。
比如我们下面这种用法：
FRFruit *fruit = [[FRFruit alloc] init];
fruit.block_Objct = ^{
NSLog(@"block %@", fruit);
};
fruit.block_Objct();
// fruit 对象里面有一个copy修饰的 block_Objct 属性
Block循环引用的原理：
我们根据OC的内存管理机制知道，当对象需要被释放时必须先释放所有指向它的指针。
所以如果要先释放fruit对象，需要释放block_Objct里面的变量，如果释放block_Objct里面的变量需要先释放block_Objct，而block_Objct又被fruit强引用，这样就出现了循环引用的问题。
那么如何解决这个问题呢？
通常我们ARC环境下面的解决办法是通过__weak指针来解决这个问题，通过上面讲的Block里面的变量是通过访问的外部变量是否是strong或weak指针来进行内部对象进行相应修饰的，所以如果访问的外部对象是weak指针时，他们的引用关系就会如下图：
weak指针解决循环引用代码如下：
FRFruit *fruit = [[FRFruit alloc] init];
__weak FRFruit *weakfruit = fruit;
fruit.block_Objct = ^{
NSLog(@"block %@", weakfruit);
};
fruit.block_Objct();
其实除了weak还有__unsafe_unretain 和 __block，其实现如下：
// __unsafe_unretain 用法
FRFruit *fruit = [[FRFruit alloc] init];
__unsafe_unretained FRFruit *weakfruit = fruit;
fruit.block_Objct = ^{
NSLog(@"block %@", weakfruit);
};
// __block 用法，主意ARC环境下 block中需要将变量只为nil，且必须调用block，才能打破循环
FRFruit *fruit = [[FRFruit alloc] init];
__block FRFruit *fruit = fruit;
fruit.block_Objct = ^{
NSLog(@"block %@", fruit);
fruit = nil; // MRC 不需要置为nil
};
fruit.block_Objct();
鉴于ARC环境下weak指针的底层实现原理（对象释放时会自动指针会自动置为nil），所以推荐使用weak来解决循环引用问题。
MRC环境下推荐使用__unsafe_unretained和 __block
4，__block 修改局部变量原理
我们知道block是不能直接修改局部auto变量的，比如以下代码编译时会直接报错：
int a = 10;
void (^Block)(void) = ^{
a = 20; // 不能修改a变量
};
Block();
因为根据计算机内存分配原理可知，a变量是在栈上的，它的内存空间在函数结束时就会被回收，而Block有可能被复制到堆空间上，堆上空间的释放由开发者控制的，所以函数结束时Block有可能还会被执行，而这时变量a已经被释放了，Block就无法找到变量a的内存进行赋值，所以这种操作是被禁止的。
如果要修改局部变量，OC提供__block 修饰来修改，其用法如下：
int a = 10;
void (^Block)(void) = ^{
a = 20;
};
Block();
那它的实现原理又是怎样的呢？接下来我们看下源码：
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
// 不加__block 时是 int a ，
// 加上__block 变成了__Block_byref_a_0 *a
__Block_byref_a_0 *a; // by ref
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_a_0 *_a, int flags=0) : a(_a->__forwarding) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
struct __Block_byref_a_0 {
void *__isa;
__Block_byref_a_0 *__forwarding;
int __flags;
int __size;
int a;
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
__Block_byref_a_0 *a = __cself->a; // bound by ref
// block里面的访问__block 修饰的变量时都会通过结构体中的 forwarding 指针来访问
(a->__forwarding->a) = 20;
}
__block 实际上是将局部变量放在 __Block_byref_a_0 对象里面，该对象里面有一个 __forwarding 指针，最开始__Block_byref_a_0 在栈上时， __forwarding 属性会指向它自己，当Block复制到堆上时，__Block_byref_a_0 对象也会复制一份到堆上，此时 __forwarding 指针指向的是堆上的那块内存，所以Block实际上访问的a变量不再是栈上的变量，而是__Block_byref_a_0对象中堆内存的那个a
forwarding 指针实现原理：
全文纯手写总结，有些地方总结的不仔细，逻辑也不太清楚，等有时间会再修改梳理一下。
如有错误请指正，感谢阅读，谢谢大家！
