Block源码解析和深入理解
Block的本质
Block是"带有自动变量值的匿名函数".
我们通过Clang（LLVM编译器）来将OC的代码转换成C++源码的形式，通过如下命令：
clang -rewrite-objc 源代码文件名
下面，我们要转换的Block语法
int main(int argc, const char * argv[]) {
void (^blk)(void) = ^{
printf("Block\n");
};
blk();
return 0;
}
该源代码通过Clang 可变换为以下形式：
/*
__block_impl （block）结构体声明
*/
struct __block_impl {
void *isa; // isa 指针，指向父类的实例。void * 相当于 id 是个实例。
int Flags; //
int Reserved;
void *FuncPtr; //函数指针 指向block代码块的实现函数
};
/*
__main_block_impl_0 匿名的block 结构体声明和实现
*/
struct __main_block_impl_0 {
struct __block_impl impl;//block 的结构体实例
struct __main_block_desc_0* Desc; //block des的指针 指向block的详情
/*
__main_block_impl_0 结构体构造函数实现
*/
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int flags=0) {
impl.isa = &_NSConcreteStackBlock; // 初始化 block 实例属性 isa ，表示该block 是 _NSConcreteStackBlock (栈)类型的代码块
impl.Flags = flags;
impl.FuncPtr = fp;// block 具体的函数实现指针
Desc = desc;//desc 指针
}
};
/*
匿名block 具体的函数实现
*/
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
printf("Block\n");
}
/*
匿名block desc 指针的具体函数实现，对block（__main_block_impl_0） 结构体实例的大小进行初始化
*/
static struct __main_block_desc_0 {
size_t reserved; // 升级所需区域
size_t Block_size;//block 实际内存大小
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0)};
/*
把多余的转换去掉，看起来就比较清楚了：
第一部分：block的初始化
__main_block_func_0: 参数一 是block语法转换的C语言函数指针。
__main_block_desc_0_DATA： 参数二 作为静态全局变量初始化的 __main_block_desc_0 结构体实例指针
struct __main_block_impl_0 tmp = __main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA);
struct __main_block_impl_0 *blk = &tmp;
第二部分：
block的执行： blk()
去掉转化部分：
(*blk -> imp.FuncPtr)(blk);
这就是简单地使用函数指针调用函数。由Block语法转换的 __main_block_func_0 函数的指针被赋值成员变量FuncPtr中，另外 __main_block_func_0的函数的参数 __cself 指向Block的值，通过源码可以看出 Block 正式作为参数进行传递的。
*/
int main(int argc, const char * argv[]) {
void (*blk)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));
((void (*)(__block_impl *))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk);
return 0;
}
针对源码的解释 大部分在代码中都注释了。需要特别指出的是：
static void __main_block_func_0(struct __main_block_impl_0 *__cself)
中的参数 __cself 是指向 __main_block_impl_0 的指针，及匿名block 自身。
扩展：该句源码类似如 OC 中的方法消息传递，OC中每个方法都默认带两个参数 一个是指向自身的实例self 一个是该方法的SEL 对象。
例如：
- (void) method: (int)argc{
NLog(@"%p %d \n",self,arg)
}
Objective - C 编译器同C++的方法一样，也将该方法作为C语言的函数来处理.源码如下：
/*
方法中 在转换成源码后 自动的添加了self, _cmd两个参数
*/
void _I_MyObjct_method_(struct Myobject *self,SEL _cmd, int arg){
NSLog (@"%p %d \n",self,arg);
}
截获自动变量值（局部变量）
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
int val; //局部变量跟block外的类型一直
const char *fmt; //跟block外的类型一致
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _dmy, int _val, const char *_fmt, int flags=0) : dmy(_dmy), val(_val), fmt(_fmt) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
int val = __cself->val; // bound by copy //block 调用外部的局部变量 实际上 相当于Copy 了一份 所以不会影响 局部变量的值 也不能修改值
const char *fmt = __cself->fmt; // bound by copy
printf("Block\n .. ,%d %s",dmy,val,fmt);
}
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)};
int main(int argc, const char * argv[]) {
int dmy = 256; //局部变量
int val = 10; // 局部变量
const char *fmt = "val = %d \n"; //局部变量
void (*blk)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, val, fmt));
((void (*)(__block_impl *))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk);
return 0;
}
源码解析：block 在调用 外部局部变量的时候 其实是将外部局部变量 copy了一份 使用的 所以在没有任何修饰符的时候是不可以修改外部局部变量的。
__block 说明符
之前的分析中，block 无法改变被截获的自动变量的值。这样极为不便：
解决这个问题有两种方法，
第一种：C 语言中有一个变量，允许block改成值。具体如下：
- 静态变量
- 静态全局变量
- 全局变量
虽然Block语法的匿名函数部分简单的转换为了C语言函数，但从这个C语言函数中访问静态全局，全局变量并没有任何改变，可直接使用。
但静态变量的情况，转换后的函数原本就设置在含有Block语法的函数外，所以无法从变量作用域访问。
看看这段代码的源码：
int global_val = 1;
static int static_global_val = 2;
int main(int argc, const char * argv[]) {
static int static_val = 3;
void (^blk)(void) = ^{
global_val += 1;
static_global_val += 2;
static_val += 3;
};
blk();
return 0;
}
该源代码中使用了Block 改写静态变量 静态全局变量 全局变量。该源代码转换后如下：
int global_val = 1; //全局变量
static int static_global_val = 2; //静态全局变量
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
int *static_val;//局部静态变量 ---> 可以看出 跟局部变量不同 这边是接受的指针
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int *_static_val, int flags=0) : static_val(_static_val) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
int *static_val = __cself->static_val; // bound by copy // 改代码跟局部变量 相似，实际上改变的是一个 复制后的指针.但该指针最终指向的 还是最初的变量值。
global_val += 1;
static_global_val += 2;
(*static_val) += 3;
}
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)};
int main(int argc, const char * argv[]) {
static int static_val = 3;
void (*blk)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, &static_val));
((void (*)(__block_impl *))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk);
return 0;
}
分析该源码：发现无论是全局 还是 静态全局 都可以在Block中直接访问 修改变量值。
然而，静态局部变量，貌似也可以正常访问，其调用原理，跟之前的局部变量的调用相似，唯一的不同是，在Block中调用的是 指向该变量的指针，并且是赋值了一份指针（但还是最终指向原来的变量）。所以我们可以在Block中改变原理变量的值。
这样就有个疑问，我们为什么不使用静态局部变量，来使用去自动变量（局部变量）的访问呢？
原因：在该静态局部变量，有变量作用域，当block超出了该作用域，执行的时候，其内部调用的静态局部变量会被废弃，我们就无法调用到。因此Block中超出变量作用域而存在的变量同静态变量一样，将不能通过指针访问原来的自动变量。
解决Block 中不能保存值这一问题的第二个方法是使用__block
int main(int argc, const char * argv[]) {
__block int val = 3;
void (^blk)(void) = ^{
val = 1;
};
blk();
return 0;
}
将上面代码用 clang 转化后如下：
/*
__block 转化成了结构体
*/
struct __Block_byref_val_0 {
void *__isa;
__Block_byref_val_0 *__forwarding; //相当于一个指向源变量的指针
int __flags;
int __size;
int val; //相当于源变量
};
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
__Block_byref_val_0 *val; // by ref //持有源变量的结构体实例
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_val_0 *_val, int flags=0) : val(_val->__forwarding) {
impl.isa = &_NSConcreteStackBlock; // block 为栈类型
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
__Block_byref_val_0 *val = __cself->val; // bound by ref ；类似于 静态局部变量 都是copy 一份指向源变量的结构体指针。
(val->__forwarding->val) = 1;//通过访问 __block 结构体 成员变量 __forwarding 来访问源变量
}
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {_Block_object_assign((void*)&dst->val, (void*)src->val, 8/*BLOCK_FIELD_IS_BYREF*/);}
static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->val, 8/*BLOCK_FIELD_IS_BYREF*/);}
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};
int main(int argc, const char * argv[]) {
__attribute__((__blocks__(byref))) __Block_byref_val_0 val = {(void*)0,(__Block_byref_val_0 *)&val, 0, sizeof(__Block_byref_val_0), 3};
void (*blk)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_val_0 *)&val, 570425344));
((void (*)(__block_impl *))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk);
return 0;
}
源码解析：__Block_byref_val_0 结构体实例的成员变量__forwarding持有指向该实例自身的指针。通过成员变量__forwarding访问成员变量val。（成员变量val是该实例自身持有的变量，它相当于原自动变量）
如图所示：
Block存储域
Block 是Objective-C对象。上面我们所创建的block类 都为_NSConcreteStackBlock.
由上面我们提到的源码可以知道：
impl.isa = &_NSConcreteStackBlock
根据 block 结构体实例的 isa 指针进行分类：
- _NSConcreteStackBlock //不难看出 其存储域在栈上
- _NSConcreteGlobalBlock // 其存储域 在全局
- _NSConcreteMallocBlock // 其存储域 在堆上
详细分类如图所示：
_NSConcreteGlobalBlock： 存在的情况：
- 记述全局变量的地方有Block语法时
- Block语法的表达式中不使用应截获的自动变量时
以上情况Block 为 全局类对象。除此之外Block语法生成的Block为栈类对象，
例如（一）：
/*
在下面的block中由于for循环的值 一直在变 所以Block截获的局部变量一直在变。
*/
typedef int (^blk_t)(int);
for (int rate = 0;rate < 10; ++rate){
blk_t blk = ^(int count){
return rate * count;
}
}
转化为源码如下：
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
int rate;
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _rate, int flags=0) : rate(_rate) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
由此可见 虽然block 声明在全局中，但由于block初始化的时候调用了局部变量，所以该block创建成栈类型的。
_NSConcreteMallocBlock ：存在的情况
在分析之前我们看下之前遗留的问题：
- Block 超出变量作用域可存在的原因
- __block变量用结构体成员变量__forwarding存在的原因
配置在全局变量上的Block,从变量作用域外也可以通过指针安全的使用。但设置在栈上的Blcok，如果其变量作用域结束，该Block就被废弃，同样的__block也配置在栈上，所以其所属的变量作用域结束，则该__block变量也会被废弃。
Block提供了将Block和__block变量从栈上复制到堆上的方法来解决这个问题
而__block 变量用结构体成员变量__forwarding可以实现无论__block变量配置在栈上还是堆上都能够正确的访问__block变量。
深入理解blocks提供的复制方法究竟是啥？
实际上当ARC有效时，编译器会进行判断自动的将block从栈上复制到堆上
如：
typedef int (^blk_t)(int);
blk_t func (int count){
return ^(int count){
return rate *count;
};
}
源码转换为：
blk_t func (int rate)
{
blk_t tmp = &__func_block_impl_0(
_func_block_func_0,&_func_block_desc_0_DATA,rate
);
tmp = objc_retainBlock(tmp);
return objc_autoreleaseReturnValue(tmp);
}
分析源码：从源码来看 在ARC状态下 block复制到堆上 实际上其引用计数增加了。
__block变量的存储域
当block从栈中 复制到堆上时，由于block持有__block变量，所以其__blcok变量也会从栈中复制到堆上，所以当block超出作用域调用__block变量也可以成功。这是和静态局部变量最大的区别。而静态局部变量，在block从栈中复制到堆上时，由于block不持有变量，所以静态局部变量不 会复制到堆上，其作用域没变。故出作用域调用会崩溃。
如图所示：
截获对象
下面我们将id对象类型的局部变量 在block中调用。id类型的对象 默认修饰符 都是__strong类型的。
typedef void (^blk_t)(id);
blk_t blk;
int main(int argc, const char * argv[]) {
{
id array = [[NSMutableArray alloc]init]; // __strong 类型修改的局部变量
blk = [^(id objc){
[array addObject:objc];
NSLog(@"array count = %ld",[array count]);
} copy];
}
blk(@"ww");
return 0;
}
分析 ：按理来说 array 对象出了大括号作用域，强引用失效 其对象就会废弃。但改代码运行正常。那么就意味着，array对象出大括号作用域时，没有被废弃 ，仍能正常访问。那么是什么原因呢，我们看下Clang之后的源码.
typedef void (*blk_t)(id);
blk_t blk;
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
id array;
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, id _array, int flags=0) : array(_array) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself, id objc) {
id array = __cself->array; // bound by copy //复制一份指针 赋值
((void (*)(id, SEL, ObjectType))(void *)objc_msgSend)((id)array, sel_registerName("addObject:"), (id)objc);
NSLog((NSString *)&__NSConstantStringImpl__var_folders_0b_9hq6xqxs5gjcxx5j_skhh8n00000gn_T_main_1808b3_mi_0,((NSUInteger (*)(id, SEL))(void *)objc_msgSend)((id)array, sel_registerName("count")));
}
/*
关键方法：该方法 相当于ARC 中的 retain方法，将对象的引用计数加一。但该方法除引用计数加一外，还有一个操作就是将block 从栈上复制到堆上，从而可以出作用域，调用id __strong修饰类型的对象。
*/
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {_Block_object_assign((void*)&dst->array, (void*)src->array, 3/*BLOCK_FIELD_IS_OBJECT*/);}
/*
dispose 相当于ARC 模式下的 release 将对象的引用计数减一。引用计数减一得同时，将堆上的block 废弃掉。
*/
static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->array, 3/*BLOCK_FIELD_IS_OBJECT*/);}
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};
int main(int argc, const char * argv[]) {
{
id array = ((NSMutableArray *(*)(id, SEL))(void *)objc_msgSend)((id)((NSMutableArray *(*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("NSMutableArray"), sel_registerName("alloc")), sel_registerName("init"));
blk = (blk_t)((id (*)(id, SEL))(void *)objc_msgSend)((id)((void (*)(id))&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, array, 570425344)), sel_registerName("copy"));///必须调用block 的copy 方法才能正常运行
}
((void (*)(__block_impl *, id))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk, (NSString *)&__NSConstantStringImpl__var_folders_0b_9hq6xqxs5gjcxx5j_skhh8n00000gn_T_main_1808b3_mi_1);
return 0;
}
//从上面的源码可以发现：前提：当block调用copy方法，从栈中复制到对象，当Block调用的局部变量是个id对象的时候，该对象在block中自动的引用计数加一，并且该block持有该对象，也就是说，对象出了作用域也能被调用，知道block 从堆上废弃掉为止。如果block 的最后没有调用copy，那么该对象值，也会随着作用域的结束而被废弃。
总结：
什么时候栈上的Block会复制到堆上呢？
- 调用Block的copy实例方法时。
- Block作为函数返回值返回时。
- 将Block赋值给附有__strong修饰符id类型的类或者Block类型成员变量时。
- 在方法名中含有usingBlock的cocoa框架方法或者GCD的API中传递Block时。
对象和__block的区别？
- 如果调用对象的Block，没有调用Copy 或者不在栈上，那么该对象出作用域就会被释放。
- 如果调用对象的Block，调用了Copy，或者Block在堆上，那么该对象的作用域跟使用__block修饰的变量的作用域一直，都会被Block所持有，并且生命周期，会随着Block的废除，而释放。
因此当Block中使用对象类型的自动变量时，除以下情形外，推荐调用Block的copy实例方法！！
- block作为函数返回值返回时。
- Block赋值给类的附加__strong修饰符的id类型或者Block类型的成员变量时。
- 向方法名中含有usingBlock的Cocoa框架方法或者GCD的API中传递Block时。
__block变量和对象
从前面我们看到__block可以修饰任意类型：
- 当然包括id对象__strong类型了，其原理是相同的：
当 block 从栈上复制到 堆上时，__block 所修饰的自动变量也会从栈上复制到堆上，使用_Block_objct_assign函数，持有赋值给__block变量的对象。当 block 废弃时，__block所修饰的自动变量，也会通过函数_Block_objct_dispose ，释放掉__block变量的对象。 - 当__weak修饰符修饰时，由于__weak修饰的自动变量出作用域后会废弃 自动置nil，所以当block调用的时候，其实是调用的nil对象所以不会崩溃，但取不到值。
- 当__block __weak 同时修饰自动变量时，还是因为__weak（不持有对象）的原因，当 block 从栈上复制到堆上时，__block变量复制到堆上的是一个nil值，所以对该变量进行的操作都是无效的。
- 当__block 和 __unsafe__unretained 同时修饰变量时，跟__weak不同，当__unsafe__unretained，所修饰的对象边nil 时 该变量不会自动置nil，而是变成野指针，所以当block 从栈上复制到堆上时，实际上__block变量是一个野指针，所以当调用的时候回出错，导致程序崩溃
- __block 和 __autoreleasing 修饰跟 上面的__unsafe__unretained是一样的。
Block 循环引用
存在循环引用的情况：当block对象 作为类的 属性或者成员变量，并且在block初始化的时候，调用了self或者self相关类的成员变量。都会引起引用循环。
解决方法：
- 使用__weak 修饰要截取的自动变量，
- 当在MRC 中时，可以使用__unsafe_unretained（弊端 不会自动置nil 容易出现野指针） 修饰。
- 可以使用__block 修饰，前提是 必须 执行block代码块，而且可以适当地在代码块中 手动的把__block变量置nil
以下是相关解决方法的实例：
实例一：
typedef void (^blk_t)(void);
@interface Myobject : NSObject
{
blk_t blk_; //成员变量
id _objc;//成员变量
}
@end
@implementation MyObject
- (id)init
{
self = [super init];
/*
分析改代码会出现两种情况的引用循环：
* 一种是：成员变量block 调用 self，self中持有block ，block中也持有self，导致引用循环，解决方法在之前 加入
__weak typeof(self) weakSelf = self;
* 第二中，虽然成员变量block没有直接调用self ，但其调用了成员变量_objc，所以也会造成引用循环:
解决方法： __weak id weakObjc = _objc;
*/
blk_ = ^{
NSLog(@"self = %@, objc = %@",self,_objc);
}
return self;
}
实例二：
typedef void (^blk_t)(void);
@interface Myobject : NSObject
{
blk_t blk_; //成员变量
}
@end
@implementation MyObject
- (id)init
{
self = [super init];
/*
此处使用__block修饰变量，是的block 持有__block变量，而__block变量持有MyObject对象，而MyObject持有block对象。出现引用循环：
然而 当 block执行的时候，__block变量废弃，从而消除引用循环
*/
__block id temp = self;
blk_ = ^{
NSLog(@"self = %@,,self);
temp = nil;
}
return self;
}
- (void)execBlock
{
blk_()
}
int main (){
id o = [[MyObject alloc] init];
[o execBlock];//必须执行 否则导致引用循环
return 0;
}
总结下__block 和 __weak 之间的优缺点：
使用__block变量的优点:
- 通过__block 变量可控制对象的持有期间
- 在不能使用__weak修饰符的环境中不使用__unsafe__unretain修饰符即可（不必担心野指针）
在执行Block时可动态的决定是否将nil或者其他对象赋值在__block变量中。
使用__block变量的缺点如下：
- 为避免循环引用必须执行Block