写在前面
Block 是 C 语言的扩充功能。可以用一句话来表示 Block 的扩充功能：带有自动变量（局部变量）的匿名函数。
基本概念
Block 定义
语法：^ 返回值类型 参数列表 表达式
^int(int count){
retrun count + 1;
}
跟普通函数就两点不同
- 没有函数名
- 带有 ^
可以省略很多部分，省略返回类型：^ 参数列表 表达式
^(int count){
retrun count + 1;
}
当没有参数的时候，参数列表也可以省略：^ 表达式
// 未省略参数列表
^(void){
NSLog(@"done");
}
// 省略参数列表
^{
NSLog(@"done");
}
Block 类型变量
先看一下 C 语言的函数指针
int func(int count) {
retrun count + 1;
}
int (*funcptr)(int) = &func;
而 Block 类型变量为：int (^blk)(int)，仅仅是把 * 改成 ^ 。
int (^blk)(int) = ^(int count){
return count + 1;
};
Block 截获外部变量和 __block 修饰符
int global_val = 1;
static int global_static_val = 1;
int main(int argc, const char * argv[]) {
int val = 1;
static int static_val = 1;
void(^blk)(void) = ^{
NSLog(@"global_val：%d", global_val);
NSLog(@"global_static_val：%d", global_static_val);
NSLog(@"val：%d", val);
NSLog(@"static_val：%d", static_val);
};
global_val++;
global_static_val++;
val++;
static_val++;
blk();
return 0;
}
/*
打印如下：
global_val：2
global_static_val：2
val：1
static_val：2
*/
通过上面例子知道，全局变量和局部静态变量在 block 表达式中，可以直接修改的；
当我们需要修改自动变量值时，需要使用 __block 修饰，否则无法编译（__block 只能修饰局部自动变量）
int main()
{
__block int val = 1;
void(^blk)(void) = ^{
val++;
NSLog(@"val：%d", val);
};
val++;
blk();
return 0;
}
/*
打印如下：
val：3
*/
底层实现
通过 clang -rewrite-objc main.m 解析下面源码
// ARC 环境
int main(int argc, const char * argv[]) {
void(^blk)(void) = ^{
NSLog(@"done");
};
blk();
return 0;
}
struct __block_impl {
void *isa;
int Flags;
int Reserved;
void *FuncPtr; //指向 block 表达式的函数指针
};
// block 实现的结构体
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 表达式的实现部分
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
NSLog((NSString *)&__NSConstantStringImpl__var_folders_47_6fxgzrp50fv6r72895k282k40000gn_T_main_01adff_mi_0);
}
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[]) {
// 生成 __main_block_impl_0 结构体实例 blk
void(*blk)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));
// 通过结构体类的函数指针，调用block表达式部分
((void (*)(__block_impl *))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk);
return 0;
}
这里可以得到一个结论：Block 底层是一个结构体实现。
再看看 clang 截获普通外部变量的结构
// ARC 环境
int global_val = 1;
static int global_static_val = 1;
int main(int argc, const char * argv[]) {
int val = 1;
static int static_val = 1;
void(^blk)(void) = ^{
NSLog(@"global_val：%d", global_val);
NSLog(@"global_static_val：%d", global_static_val);
NSLog(@"val：%d", val);
NSLog(@"static_val：%d", static_val);
};
blk();
return 0;
}
int global_val = 1;
static int global_static_val = 2;
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
int val; // 局部自动变量，值传递
int *static_val; // 局部静态变量，指针传递
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _val, int *_static_val, int flags=0) : val(_val), 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 val = __cself->val; // bound by copy
int *static_val = __cself->static_val; // bound by copy
// 全局变量直接访问
NSLog((NSString *)&__NSConstantStringImpl__var_folders_47_6fxgzrp50fv6r72895k282k40000gn_T_main_09c968_mi_0, global_val);
NSLog((NSString *)&__NSConstantStringImpl__var_folders_47_6fxgzrp50fv6r72895k282k40000gn_T_main_09c968_mi_1, global_static_val);
// 局部变量，通过传递访问
NSLog((NSString *)&__NSConstantStringImpl__var_folders_47_6fxgzrp50fv6r72895k282k40000gn_T_main_09c968_mi_2, val);
NSLog((NSString *)&__NSConstantStringImpl__var_folders_47_6fxgzrp50fv6r72895k282k40000gn_T_main_09c968_mi_3, (*static_val));
}
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 val = 3;
static int static_val = 4;
void(*blk)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, val, &static_val));
((void (*)(__block_impl *))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk);
return 0;
}
小结如下：
| 变量类型 | 访问方式 | 是否捕获到block内部 |
|---|---|---|
| 局部自动变量 | 值传递 | 是 |
| 局部静态变量 | 指针传递 | 是 |
| 全局变量 | 直接访问 | 否 |
继续看 __block 修饰的自动变量会是怎么样的
// ARC 环境
int main()
{
__block int val = 1;
void(^blk)(void) = ^{
val++;
NSLog(@"val：%d", val);
};
val++;
blk();
return 0;
}
// __block 修饰的变量 val，转换为结构体
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;
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
(val->__forwarding->val)++;
NSLog((NSString *)&__NSConstantStringImpl__var_folders_47_6fxgzrp50fv6r72895k282k40000gn_T_main_bfcad8_mi_0, (val->__forwarding->val));
}
// 可以理解为 retain
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*/);
}
// 可以理解为 release
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()
{
__attribute__((__blocks__(byref))) __Block_byref_val_0 val = {(void*)0,(__Block_byref_val_0 *)&val, 0, sizeof(__Block_byref_val_0), 1};
void(*blk)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_val_0 *)&val, 570425344));
(val.__forwarding->val)++;
((void (*)(__block_impl *))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk);
return 0;
}
我们发现通过 __block 修饰的自定变量转换为 __Block_byref_a_0 结构体，而且多了一个 __forwarding 指针。在分析 __forwarding 之前，先分析一下 _NSConcreteStackBlock，Block 结构体中都会有一个 isa 指针指向 _NSConcreteStackBlock ，了解 objc 底层就会知道，isa 一般都是指向对象的所属类，也就是说 Blcok 也可以当做一个 objc 类理解。
在上面例子中出现的都是 _NSConcreteStackBlock，那么 _NSConcreteGlobalBlock 和 _NSConcreteMallocBlock 是在什么条件生成的？
_NSConcreteGlobalBlock
void(^blk)(void) = ^{
NSLog(@"done");
};
int main(int argc, const char * argv[]) {
blk();
return 0;
}
clang 之后
struct __blk_block_impl_0 {
struct __block_impl impl;
struct __blk_block_desc_0* Desc;
__blk_block_impl_0(void *fp, struct __blk_block_desc_0 *desc, int flags=0) {
impl.isa = &_NSConcreteGlobalBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
还有一种情况是，只要不截获自动变量就会分配到数据区域
int a = 1;
int main(int argc, const char * argv[]) {
void(^blk)(void) = ^{
NSLog(@"%d", a);
};
blk();
return 0;
}
虽然通过 clang 转换为 _NSConcreteStackBlock，实际上却不同，可以通过断点打印验证；
总结起来就是：如果 Block 表达式中没有截获自动变量，那么 Block 的内存会分配在数据区域。
_NSConcreteStackBlock 与 _NSConcreteMallocBlock
如果不是分配在数据区域的对象，那么就是分配在栈上；至于堆上的 Block，需要对 Block 对象调用 copy 方法，才能移到堆上，ARC 下系统会在合适的时机自动移到堆上。
接下来分析，堆和栈的区别？以及系统在哪些情况下会自动移动到堆上？
- 栈上的 Block：超过作用域就会释放
- 堆上的 Block：通过引用计数管理
// MRC 环境下
+ (void)test
{
int a = 1;
void(^blk)(void) = ^{
NSLog(@"%d", a);
};
NSLog(@"blk：%@", blk);
NSLog(@"blk copy：%@", [blk copy]);
}
/*
打印如下：
blk：__NSStackBlock__
blk copy：__NSMallocBlock__
*/
小结如下：
| 类 | 内存区域 | 条件 |
|---|---|---|
_NSConcreteGlobalBlock(__NSGlobalBlock__) |
数据区域（.data区） | 表达式中没有截获自动变量 |
_NSConcreteStackBlock(__NSStackBlock__) |
栈区 | 表达式中截获自动变量 |
_NSConcreteMallocBlock(__NSMallocBlock__) |
堆区 |
__NSStackBlock__调用了copy |
系统在哪些情况下会自动移动到堆上？这个需要分 MRC 和 ARC 的情况来考虑。
// ARC 环境
typedef int(^block)(int);
block getBlock(int rate)
{
return ^(int count) {
return rate * count;
};
}
在 ARC 下通过编译器可转换如下：
block getBlock(int rate)
{
// ARC 下会默认修饰符 __strong，block tmp = XXX; 相当于 __strong block tmp = XXX;
block tmp = &__getBlock_block_impl_0((void *)__getBlock_block_func_0, &__getBlock_block_desc_0_DATA), rate);
// 相当于普通 oc 对象的 objc_retain 函数；内部会调用 _Block_copy(tmp);
tmp = objc_retainBlock(tmp);
// 把 tmp 注册到 autoreleasepool 中
return objc_autoreleaseReturnValue(tmp);
}
_Block_copy 函数就是把 Block 从栈上复制到堆上。到这里就可以解释为什么 MRC 下，block 经常需要手动调用 copy，属性修饰符也一般都要使用 copy，比如：@property (nonatomic, copy) block blk;，主要目的是把 Block 从栈上拷贝到堆上。
ARC 自动 copy 到堆上的情况
- Block 作为函数返回值时
- 将 Block 赋值给 __strong 指针时
- Block 作为 Cocoa API 中方法名含有 usingBlock 的方法参数时
- Block 作为 GCD API 的方法参数时
有了这些做基础，接下来解释 __block 修饰的变量，生成的结构中 __forwarding 的作用了。
先说结论：通过 __forwarding 指针访问，保证每次都能访问到合适的内存。
当 block 还在栈上时，__forwarding 指向的是栈上的结构体对象；
Block_img_02.jpg
当 block 复制到堆上时，堆上的 __forwarding 指向堆上的结构体，栈上的 __forwarding 指向堆上的结构体
Block_img_01.jpg
所以通过 __forwarding->val 访问结构体中的值会永远都是合适的。
总结：Block 本质就是一个结构体，并且可以截获内部使用的自动变量作为结构体的成员变量。
几个注意的地方
循环引用问题
如果在 Block 中使用附有 __strong 修饰符的自动变量，那么当 Block 从栈复制到堆时，该对象为 Block 所强引用，这样就会引起循环引用。
先看一个经典例子
// ARC 环境
typedef void(^Block)(void);
@implementation ARCObject
{
Block _blk;
NSString *_str;
}
+ (void)test
{
ARCObject *obj = [ARCObject new];
obj->_str = @"string";
obj->_blk = ^{
NSLog(@"%@", obj->_str);
};
obj->_blk();
}
@end
clang 之后的结构体如下
struct __ARCObject__test_block_impl_0 {
struct __block_impl impl;
struct __ARCObject__test_block_desc_0* Desc;
ARCObject *obj; // 强引用
__ARCObject__test_block_impl_0(void *fp, struct __ARCObject__test_block_desc_0 *desc, ARCObject *_obj, int flags=0) : obj(_obj) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
再看另一个经典例子，只访问了成员变量
// ARC 环境
typedef void(^Block)(void);
@implementation ARCObject
{
Block _blk;
NSString *_str;
}
- (void)test
{
_str = @"string";
_blk = ^{
NSLog(@"%@", _str);
};
_blk();
}
@end
clang 之后的结构体如下
struct __ARCObject__test_block_impl_0 {
struct __block_impl impl;
struct __ARCObject__test_block_desc_0* Desc;
ARCObject *self; // 强引用整个对象
__ARCObject__test_block_impl_0(void *fp, struct __ARCObject__test_block_desc_0 *desc, ARCObject *_self, int flags=0) : self(_self) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
我们发现当 Block 访问的是对象的成员变量时，会把对象的指针传给 Block。
避免循环引用使用 __weak 修饰就可以了，比如上面列子，因为 __weak 是运行时添加的，所以没法 clang 出来。
// ARC 环境
typedef void(^Block)(void);
@implementation ARCObject
{
Block _blk;
NSString *_str;
}
- (void)test
{
_str = @"string";
__weak typeof(_str) weakStr = _str;
_blk = ^{
NSLog(@"%@", weakStr);
};
_blk();
}
@end
总结
现在就比较好理解：Block 是一个带有自动变量（局部变量）的匿名函数。
- 通过一个结构体实现 Block，然后把 Block 表达式中使用的局部变量（局部自动变量、局部静态变量）设置为结构体的成员变量；
- Block 内存管理的方式，ARC 模式下，大部分情况编译器会自动帮我们完成从栈拷贝到堆上，然后通过引用计数管理 Block 对象。以下为编译器自动完成拷贝的情况：
- Block 作为函数返回值时
- 将 Block 赋值给 __strong 指针时
- Block 作为 Cocoa API 中方法名含有 usingBlock 的方法参数时
- Block 作为 GCD API 的方法参数时
