前言
在Objective-C中，block是一个很常见的东西，说白了就是个匿名函数，网上有很多关于block如何使用的文章，讲的都非常精彩，这里主要探讨下block的实现原理。关于如何使用block，请参考网上的教程。
实例
先来新建一个控制台工程，main.m里的代码如下，并思考下最后的输出结果是什么：
void blockFunc1() {
int num = 100;
void (^block)(void) = ^() {
NSLog(@"num = %d\n", num);
};
num = 200;
block();
}
void blockFunc2() {
__block int num = 100;
void (^block)(void) = ^() {
NSLog(@"num = %d\n", num);
};
num = 200;
block();
}
int num = 100;
void blockFunc3() {
void (^block)(void) = ^() {
NSLog(@"num = %d\n", num);
};
num = 200;
block();
}
void blockFunc4()
{
static int num = 100;
void (^block)(void) = ^{
NSLog(@"num = %d", num);
};
num = 200;
block();
}
int main(int argc, const char * argv[]) {
@autoreleasepool {
^{ printf("Hello, World!\n"); } ();
blockFunc1();
blockFunc2();
blockFunc3();
blockFunc4();
}
return 0;
}
打印结果是：
Hello, World!
2018-03-21 15:50:01.996591+0800 BlockDemo[34825:4848536] num = 100
2018-03-21 15:50:01.997009+0800 BlockDemo[34825:4848536] num = 200
2018-03-21 15:50:01.997025+0800 BlockDemo[34825:4848536] num = 200
2018-03-21 15:50:01.997037+0800 BlockDemo[34825:4848536] num = 200
聪明的读者应该早就知道这个结果，😁，先简单解释一下:
1、^{ printf("Hello, World!\n"); } ();
这个没啥好说的，肯定就打印“Hello, World!”了。
2、blockFunc1里面,num是以值传递的方式被block获取，所以尽管后面更改了num的值，但是在block里面还是保持保持原来的值。
2、blockFunc2里面，num由__block修饰，num在block变成了外部的一个引用（后面会通过源码解释），所以在block外部改变num的值时，block里面的num也随着改变。
3、blockFunc3里面，block引用的是一个全局的num，所以，num改变的时候也会改变block内部num的值。
4、blockFunc3里面，block引用的是一个static的num，所以，num改变也会改变block内部的num的值。
源码分析
也许大家看到上面的解释还是不知道为啥会这样，所以接下，我通过源码来分析下其中的缘由，我们先把这段先转换成c++文件，cd到main.m所在的目录，并执行这条命令clang -rewrite-objc main.m，通过这条命令可以把main.m文件转换成cpp文件，里面可以看到block的结构。我们打开这份文件，这个文件比较长，直接拉到最后。可以看到在文件的最后是main函数的入口，代码如下：
int main(int argc, const char * argv[]) {
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA)) ();
blockFunc1();
blockFunc2();
blockFunc3();
blockFunc4();
}
return 0;
}
先看第一行代码，构造了一个__main_block_impl_0对象，__main_block_impl_0是一个结构体。相关代码如下：
struct __block_impl {
void *isa;
int Flags;
int Reserved;
void *FuncPtr;
};
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;
}
};
从代码可知，最后block会转化成一个__block_impl对象，而block执行的代码会转化成一个静态函数，__block_impl里面的FuncPtr会指向这个静态函数。在这里printf("Hello, World!\n");这个block转换后的静态函数如下：
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
printf("Hello, World!\n");
}
所以整个过程是这样的：
1、先构造一个__main_block_impl_0对象，构造的时候把__main_block_func_0传进去，当然还有别的参数，这里先不考虑。
2、在__main_block_impl_0的构造方法中，再把__main_block_func_0赋给__block_impl的FuncPtr。
3、调用FuncPtr。
所以，从上面可以看出，block实际上是转化为了一个__block_impl对象，这个对象有isa指针，用来表示block的类型，上面的block的isa指向&_NSConcreteStackBlock。同时block对象还有一个FuncPtr指针，用来指向block执行的方法（转换后的静态函数）。
再来看看blockFunc1相关的内容
struct __blockFunc1_block_impl_0 {
struct __block_impl impl;
struct __blockFunc1_block_desc_0* Desc;
int num;
__blockFunc1_block_impl_0(void *fp, struct __blockFunc1_block_desc_0 *desc, int _num, int flags=0) : num(_num) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
static void __blockFunc1_block_func_0(struct __blockFunc1_block_impl_0 *__cself) {
int num = __cself->num; // bound by copy
NSLog((NSString *)&__NSConstantStringImpl__var_folders_rv_338km0ws0gb2gk132_zrs0wc0000gp_T_main_b5d67f_mi_0, num);
}
void blockFunc1() {
int num = 100;
void (*block)(void) = ((void (*)())&__blockFunc1_block_impl_0((void *)__blockFunc1_block_func_0, &__blockFunc1_block_desc_0_DATA, num));
num = 200;
((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
}
在这个函数里面，构造block的时候把num传了进去，而且是普通值传递，这样的话其实是拷贝了一份num。然后在执行block方法的时候，使用的是拷贝的那份num，从int num = __cself->num; // bound by copy可以看出。这个block也是_NSConcreteStackBlock类型的。
再来看看__block修饰过的num在block里面是怎么传递的，我们看看blockFunc2相关的代码：
// 封装num的结构
struct __Block_byref_num_0 {
void *__isa;
__Block_byref_num_0 *__forwarding;
int __flags;
int __size;
int num;
};
struct __blockFunc2_block_impl_0 {
struct __block_impl impl;
struct __blockFunc2_block_desc_0* Desc;
__Block_byref_num_0 *num; // by ref
__blockFunc2_block_impl_0(void *fp, struct __blockFunc2_block_desc_0 *desc, __Block_byref_num_0 *_num, int flags=0) : num(_num->__forwarding) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
static void __blockFunc2_block_func_0(struct __blockFunc2_block_impl_0 *__cself) {
__Block_byref_num_0 *num = __cself->num; // bound by ref
NSLog((NSString *)&__NSConstantStringImpl__var_folders_rv_338km0ws0gb2gk132_zrs0wc0000gp_T_main_b5d67f_mi_1, (num->__forwarding->num));
}
void blockFunc2() {
__attribute__((__blocks__(byref))) __Block_byref_num_0 num = {(void*)0,(__Block_byref_num_0 *)&num, 0, sizeof(__Block_byref_num_0), 100};
void (*block)(void) = ((void (*)())&__blockFunc2_block_impl_0((void *)__blockFunc2_block_func_0, &__blockFunc2_block_desc_0_DATA, (__Block_byref_num_0 *)&num, 570425344));
(num.__forwarding->num) = 200;
((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
}
从代码中可以看到，__block修饰的num在内部被包装成一个__Block_byref_num_0的对象，假设叫a，原来num的值100存储在对象a的num字段中，同时这个对象a有一个__forwarding字段，指向a本身。当改变num的值的时候（源代码是num = 200;），这段代码变为(num.__forwarding->num) = 200;，也就是说把对象a里面的num字段的值变为了200。同时，在block的执行函数__blockFunc2_block_func_0中，打印出来的取值是从__Block_byref_num_0 *num = __cself->num;取出，也就是取得是改变后的值，所以打印结果是200。这就是为什么用__block修饰的变量可以在block内部被修改。
那当num为全局变量的时候，block又是怎样的呢？请看代码：
static void __blockFunc3_block_func_0(struct __blockFunc3_block_impl_0 *__cself) {
NSLog((NSString *)&__NSConstantStringImpl__var_folders_rv_338km0ws0gb2gk132_zrs0wc0000gp_T_main_b5d67f_mi_2, num);
}
void blockFunc3() {
void (*block)(void) = ((void (*)())&__blockFunc3_block_impl_0((void *)__blockFunc3_block_func_0, &__blockFunc3_block_desc_0_DATA));
num = 200;
((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
}
从代码里可以看出，这种情况很简单，block对象根本没有num字段，也就是打印的时候直接取得全局的num。
最后一种情况也很简单，当num时static的时候，构造block对象的时候直接用引用传值的方式把num放到block对象中。所以，当外部改变num的值的时候，也能反映到block内部。代码如下：
void blockFunc4()
{
static int num = 100;
void (*block)(void) = ((void (*)())&__blockFunc4_block_impl_0((void *)__blockFunc4_block_func_0, &__blockFunc4_block_desc_0_DATA, &num));
num = 200;
((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
}
总结
这篇文章主要从源码的角度讲述了block的实现机制，并针对四种情况分析了block是如何引用外部变量的，分别是:
1、当引用局部变量的时候，如果没有__block修饰，那么在block内部获取的是外部变量的一份拷贝，改变外部变量不影响block内部的那份拷贝。
2、当引用局部变量的时候，同时局部变量用__block修饰，那么在block内部使用的实际上是外部变量的一个引用，所以改变外部变量会影响block内部变量的值。
3、当引用全局变量的时候，block并不持有这个变量。
4、当引用static变量的时候，block会以引用的方式持有这个变量。当在外部修改这个变量的时候，会影响block内部持有的这个变量的值。
