iOS Blocks 第二弹｜底层实现
揭秘 Block 的底层实现
上一篇关于 Block 基础知识的文章里，提到 Block 是对标准 C 的拓展，它的底层还是依赖标准 C/C++ 实现的。这篇文章就来揭秘一下 Block 的底层实现。
利用 clang 转译 Objc 源码
利用 clang 的 -rewrite-objc 参数可以将 Objc 源码转译为标准 C 代码（输出文件格式为 .cpp ）。虽说输出是 C++ 文件，但其实内部主要还是用标准 C 写的，只不过某些用到了 struct 构造器的地方是 C++ 的特性。
在终端直接使用 clang -rewrite-objc file.m 指令转译 Objc 代码会出现找不到系统库头文件的问题。这时候需要在指令里加上 -isysroot `xcrun --show-sdk-path` 指定 SDK 的路径：clang -isysroot `xcrun --show-sdk-path` -rewrite-objc file.m 。
-fobjc-arc 参数。 clang -isysroot `xcrun --show-sdk-path` -rewrite-objc -fobjc-arc block_auto_copy.mC++ 中的 this 和 Objective-C 中的 self
C++ 源码也能借助 clang 转成标准 C 实现，我们借此先了解一下 this 和 self 。
C++ 中的 this
在 C++ 中定义一个实例方法，并在 main 函数中调用：
#include <stdio.h>
class MyClass {
public:
void method(int param);
};
void MyClass::method(int param) {
printf("%p %d\n", this, param);
}
int main() {
MyClass obj;
obj.method(10);
}将上面代码转译为标准 C 实现：
#include <stdio.h>
struct MyClass {
void (*method)(struct MyClass* self, int param);
};
void method(struct MyClass* self, int param) {
printf("%p %d\n", self, param);
}
int main() {
struct MyClass obj;
obj.method = method;
obj.method(&obj, 10);
}可以看到 C++ 的类在标准 C 里面是使用 struct 实现的。实例方法 method 转为标准 C 实现后，变成了一个单独的函数，并且参数里多了一个 struct Myclass* self，即实例本身（实际为 struct）。Myclass 结构体里面存储了 method 的指针，调用实例方法时通过这个指针找到对应的函数。
实例在调用自己的实例方法时，也是将自己的地址作为参数传递了进去：cls.method(&obj, 10); 。这就是 C++ 中的 this 。
Objective-C 中的 self
同样使用 clang 将下面这段代码转译为标准 C 实现：
#include <Foundation/Foundation.h>
@interface MyClass : NSObject
@end
@implementation MyClass
- (void)method:(int)param {
NSLog(@"%p %d\n", self, param);
}
@end
int main(int argc, const char * argv[]) {
MyClass *obj = [[MyClass alloc] init];
[obj method:10];
return 0;
}标准 C 实现：
#ifndef _REWRITER_typedef_MyClass
#define _REWRITER_typedef_MyClass
typedef struct objc_object MyClass;
typedef struct {} _objc_exc_MyClass;
#endif
struct MyClass_IMPL {
struct NSObject_IMPL NSObject_IVARS;
};
/* @end */
// @implementation MyClass
static void _I_MyClass_method_(MyClass * self, SEL _cmd, int param) {
NSLog((NSString *)&__NSConstantStringImpl__var_folders_kk_801wlmp11577d334vqtg_vgr0000gn_T_main_4bc26d_mii_0, self, param);
}
// @end
int main(int argc, const char * argv[]) {
MyClass *obj = ((MyClass *(*)(id, SEL))(void *)objc_msgSend)((id)((MyClass *(*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("MyClass"), sel_registerName("alloc")), sel_registerName("init"));
((void (*)(id, SEL, int))(void *)objc_msgSend)((id)obj, sel_registerName("method:"), 10);
return 0;
}和 C++ 一样，self 也是被作为了一个参数传递给了 _I_MyClass_method_ 函数。而 _I_MyClass_method_ 函数对应着源码 method 函数，且变成了一个静态函数。静态函数的好处之一就是其他文件中可以定义相同名字的函数，不会发生冲突。
在调用 method 函数时，标准 C 实现里使用了 objc_msgSend 函数。这也是我们常说的，Objc 的方法调用其实就是向对象发送消息。objc_msgSend 函数会通过对象名和方法名检索 _I_MyClass_method_ 的函数指针，通过函数指针调用函数，并将实例本身 obj 作为第一个参数传递进去。
Blocks 的底层实现
简易 Block 的标准 C/C++ 实现
利用 clang 将下面代码转译为标准 C/C++ 代码：
int main(int argc, const char * argv[]) {
void (^blk)(void) = ^{
printf("Block\n");
};
blk();
return 0;
}转译结果：
#ifndef BLOCK_IMPL
#define BLOCK_IMPL
struct __block_impl {
void *isa;
int Flags;
int Reserved;
void *FuncPtr;
};
// Runtime copy/destroy helper functions (from Block_private.h)
#ifdef __OBJC_EXPORT_BLOCKS
extern "C" __declspec(dllexport) void _Block_object_assign(void *, const void *, const int);
extern "C" __declspec(dllexport) void _Block_object_dispose(const void *, const int);
extern "C" __declspec(dllexport) void *_NSConcreteGlobalBlock[32];
extern "C" __declspec(dllexport) void *_NSConcreteStackBlock[32];
#else
__OBJC_RW_DLLIMPORT void _Block_object_assign(void *, const void *, const int);
__OBJC_RW_DLLIMPORT void _Block_object_dispose(const void *, const int);
__OBJC_RW_DLLIMPORT void *_NSConcreteGlobalBlock[32];
__OBJC_RW_DLLIMPORT void *_NSConcreteStackBlock[32];
#endif
#endif
#define __block
#define __weak
// 省略了一些无关的代码
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;
}
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
printf("Block\n");
}
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[]) {
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 struct IMAGE_INFO { unsigned version; unsigned flag; } _OBJC_IMAGE_INFO = { 0, 2 };从标准 C/C++ 代码里可以看出来，Block 在底层是利用一个主逻辑函数和一个负责存储数据的结构体实现的。函数 __main_block_func_0 负责处理 Block 的主要计算逻辑，而存储数据的结构体 __main_block_impl_0 负责存储前者的指针（函数指针），以及需要给函数传递的参数等。在后面的章节里面，我们还会发现，Block 外部被捕获的变量也会存储在 __main_block_impl_0 里。
函数 __main_block_func_0 函数接受一个 _cself 参数，这个参数就类似于 C++ 中的 this，以及 Objc 中的 self。只不过 _cself 代表着 Block 自己，相当于把 Block 当成一个对象了。
__main_block_func_0 以及 __main_block_impl_0 这俩名字是根据原始 Objc 代码中 Block 声明所在的函数的名字，以及是函数中第几个 Block 来定下的。
这就是一个简单的 Block 的底层实现，接下来我们会更深入地分析底层实现的源码。
__cself 结构体的结构
在上面转译之后的 C 代码中，__main_block_func_0 函数接受的 _cself 参数是 __main_block_impl_0 类型的。其结构体定义如下：
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_impl类型的 impl 。是一个结构体，存储 Block 的基本实现信息，比如对应的函数指针。__main_block_desc_0类型的 Desc 。也是一个结构体，存储 Block 的 size 等信息。定义如下，里面直接定义了一个__main_block_desc_0类型的静态全局变量__main_block_desc_0_DATA，方便创建__main_block_impl_0时直接使用。__main_block_impl_0结构体的构造器。
其中 __block_impl 结构体是 Blocks 通用的，并不是专门为某个 Block 定义的。定义如下：
struct __block_impl {
void *isa;
int Flags;
int Reserved;
void *FuncPtr;
};里面存储了 Block 对应的实现函数的指针，标志，isa 等信息，可以称作 Block 的「基类」。
简化一下__main_block_impl_0 结构体，去掉构造函数：
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
};这个结构体整体可以作为 Block 的身份信息，也可以说是 Block 的类似于 class 的声明，这就是 __cself 的意义。
__main_block_impl_0 内部还定义了一个构造器：
__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 的实例。
调用这个构造器的代码：
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);第一行代码调用了 __main_block_impl_0 的构造函数，将生成的 __main_block_impl_0 实例的地址赋给了变量 blk。也就是说 blk 目前是 __main_block_impl_0 类型的指针，并且其指向的实例是一个在栈上创建的局部变量（MRC 环境下）。
__main_block_func_0 的调用逻辑
未转译时的 Objc 源码在执行 Block 时的代码是 blk(); ，这行代码对应于转译后的代码：
((void (*)(__block_impl *))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk);因为 blk 的类型是 __main_block_impl_0，其结构体中第一个元素是 __block_impl 类型的 impl。从内存结构上来说，可以通过成员 impl 的偏移量（是 0）来直接获取成员的地址并访问成员。因此 (__block_impl *)blk 这块代码直接将 blk 转成了 __block_impl 类型。
关于 struct 的内存结构，可以参考我之前的 post：
去掉各种类型转换，可以简化为：
(*blk->impl.FuncPtr)(blk);简化后的代码一目了然，调用了 FuncPtr 指向的函数，并将 blk 自己作为 __cself 传递了进去。
isa = &_NSConcreteStackBlock 的含义
在 __main_block_impl_0 的构造器中，有这样一句代码：
impl.isa = &_NSConcreteStackBlock;这句代码将_NSConcreteStackBlock 的地址赋给了 isa。为了理解 isa 是什么，我们首先得知道 Objective-C 中的 class 和 object 是怎么实现的。
在 Objective-C 中我们经常将一个对象的指针赋值给一个 id 类型的变量，它就像 C 语言中的 void * 。其实 id 也是在 C 语言中声明和实现的：
// objc.h
/// Represents an instance of a class.
struct objc_object {
Class _Nonnull isa OBJC_ISA_AVAILABILITY;
};
/// A pointer to an instance of a class.
typedef struct objc_object *id;id 是一个指向 objc_object 类型的指针。而 Class 的定义为：
/// An opaque type that represents an Objective-C class.
typedef struct objc_class *Class;
struct objc_class : objc_object {
Class superclass;
}objc_object 和 objc_class 是 Objective-C 中对象和类最基础的结构体。objc_object 指代类的实例，而 objc_class 指代实例的类型。其实不难发现，objc_class 其实构成了类似于链表的结构，内部装了同一类型的另一个变量。逐个遍历这个链表，就能一层一层拿到父级、父级的父级等的类型信息。
isa = &_NSConcreteStackBlock 意思是当 Block 被视为一个 object 时，我们能从 _NSConcreteStackBlock 中溯源到我们想要的关于 Block 类型的信息。
至于 _NSConcreteStackBlock ，我们后面的章节会具体讲到它以及和它相关的另外几种类型。
Block 对局部变量的捕获及修改
接下里的篇章就是重头戏了。Block 最重要的能力就是能捕获局部变量，关联上下文信息。
捕获变量的底层实现
将下面这段代码转换成标准 C/C++ 实现。
int main() {
int dmy = 256;
int val = 10;
const char *fmt = "val = %d\n";
void (^blk)(void) = ^{ printf(fmt, val); };
blk();
return 0;
}转换结果：
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
const char *fmt;
int val;
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, const char *_fmt, int _val, int flags=0) : fmt(_fmt), val(_val) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
const char *fmt = __cself->fmt; // bound by copy
int val = __cself->val; // bound by copy
printf(fmt, 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 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, fmt, val));
((void (*)(__block_impl *))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk);
return 0;
}在 blk 中使用到的局部变量 fmt 和 val 在 __main_block_impl_0 中有了对应的成员变量，而 blk 没有使用的局部变量 dmy 则没有处理。
__main_block_impl_0 的构造函数中也多了对 fmt 和 val 的初始化操作。在对 blk 进行初始化时，将局部变量 fmt 和 val 作为参数传递给了 __main_block_impl_0 的构造函数。
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, const char *_fmt, int _val, int flags=0) : fmt(_fmt), val(_val)这不仅印证了上面提到的，__main_block_impl_0 是专门存储数据的，包括了上下文信息；也解释了为什么 Block 里面的 self 要用 __weak 来处理——__main_block_impl_0 里面又（隐式）强持有了 self。
为什么 Block 不能捕获 C 数组
源码 ^{ printf(fmt, val); } 对应的标准 C/C++ 实现代码对应着 __main_block_func_0 函数。
变量 fmt 和 val 现在是从 __cself 中取出的，也就是从 __main_block_impl_0 里面取出来的。
前面章节中说过，Blocks 是无法捕获 C 数组的。至于为什么不能这么干，我们可以先写个简短的代码实验。
char a[10] = "hello";
char b[10] = a;上面这段代码编译时会报错：Array initializer must be an initializer list or string literal.
意思是必须用字面意义上的数组或者字符串初始化数组，不能用另外一个数组直接初始化。这就是为啥 Block 无法捕获 C 数组的原因。如果 Block 捕获了 C 数组，那么之后在执行 Block 内部代码时，肯定会有类似 int val = __cself->val; 的操作；如果把这个操作放在 C 数组上，那就是用一个 现有的 C 数组来初始化一个局部变量，会报编译错误。
修改被捕获的局部变量的值
一般情况下，局部变量（非全局/静态）被捕获后，在 struct 内部生成的与之对应的变量（__main_block_impl_0 里面的 val，下称「镜像变量」）是不允许修改值的。因为编译器是把被捕获变量的值赋给了镜像变量，并不是让镜像变量指向被捕获变量，他们是两个独立的变量。如果镜像变量能修改值的话，那其意义就不存在了。
尽管如此，我们还是有一些场景需要修改被捕获变量的值，比如在 Block 中修改计次数。
使用静态变量或者全局变量
前面说到被捕获的变量和镜像变量是相互独立的，但也有特例，比如静态变量或全局变量。在 C 语言中，我们经常使用以下几种变量做持久存储或共享信息：
- 静态变量
- 静态全局变量
- 全局变量
全局变量和静态全局变量能够在同一文件中任意地方访问。因此在将源码转成标准 C/C++ 实现后，Block 的逻辑函数里也能对全局变量和静态全局变量直接访问，不需要生成镜像变量来存储全局变量/静态全局变量的值。
用下面这段代码做个实验：
int global_val = 1;
static int static_global_val = 2;
int main() {
static int static_val = 3;
void (^blk)(void) = ^ {
global_val *= 1;
static_global_val *= 2;
static_val *= 3;
};
blk();
return 0;
}转换成标准 C/C++ 实现：
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() {
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;
}可以发现，全局变量 global_val 和静态全局变量 static_global_val 在 block 的实现函数 __main_block_impl_0 里并没有生成对应的镜像变量，在逻辑函数 __main_block_func_0 里也是直接访问的这两个变量。
但静态变量有些不同，因为静态变量尽管生命周期比普通的局部变量长，但是其作用域还是被限制在了函数内部，无法在 main 函数外访问，也无法在 __main_block_func_0 里访问。
静态变量毕竟是和普通变量有很大差别的，如果按照普通变量的方式给静态变量生成一个镜像变量，那绝对是不能的。标准 C/C++ 实现中解决这一问题的方式是使用指针，让指针指向静态变量。在 __main_block_impl_0 的构造过程中传入了 static_val 的地址：
void (*blk)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, &static_val));使用 __block 关键字
在 C 语言中，有下面几个存储类型关键字，表明变量存储的位置：
- typedef 为现有类型添加一个同义字
- extern 声明一个已经在别处定义了的变量
- static 静态变量
- auto 变量具有自动存储时期，一般是存储在栈区的局部变量
- register 将一个变量归入寄存器存储类，具备更快的读写速度
__block 关键字和上面这几个关键字类似，也是说明了变量的存储类型，下面我们来具体看一下。
老规矩，还是看下 __block 的标准 C/C++ 实现：
int main() {
__block int val = 10;
void (^blk)(void) = ^ {
val = 1;
};
}转译后：
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) = 1;
}
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() {
__attribute__((__blocks__(byref))) __Block_byref_val_0 val = {(void*)0,(__Block_byref_val_0 *)&val, 0, sizeof(__Block_byref_val_0), 10};
void (*blk)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_val_0 *)&val, 570425344));
}原始代码里面简单的 __block int val = 10; ，在标准实现里面变成了：
__attribute__((__blocks__(byref))) __Block_byref_val_0 val = {(void*)0,(__Block_byref_val_0 *)&val, 0, sizeof(__Block_byref_val_0), 10};val 在标准实现里面变成了 __Block_byref_val_0 类型的结构体，不再是一个单一的变量。在这个结构体里面，又有一个 int 类型的成员变量 val ，存储着原始的 val ，它是可以更改值的。
在 Block 里面修改局部变量 val 的值，对应着修改 __Block_byref_val_0 里面的 val ：
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) = 1;
}每个被 __block 修饰的变量都会在标准 C/C++ 实现里生成一个类似 __Block_byref_val_0 的结构体。如果有多个 Block 内部都要修改同一个被 __block 修饰的变量的话，这些 Block 被初始化时会接受这个变量对应的 __Block_byref_val_0 类型的结构体地址：
__block int val = 10;
void (^blk)(void) = ^ {
val = 1;
};
void (^blk1)(void) = ^ {
val = 2;
};转译后：
__attribute__((__blocks__(byref))) __Block_byref_val_0 val = {(void*)0,(__Block_byref_val_0 *)&val, 0, sizeof(__Block_byref_val_0), 10};
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 (*blk1)(void) = ((void (*)())&__main_block_impl_1((void *)__main_block_func_1, &__main_block_desc_1_DATA, (__Block_byref_val_0 *)&val, 570425344));把 __Block_byref_val_0 这种类型的结构体单独拆出来，是为了方便多个 Block 捕获同一个 __block 变量。
看到这里，我们应该大致理解了 __block 关键字的原理：被 __block 标记的变量会在底层实现里变成一个结构体，这个结构体可以在 Block 之间共享，修改变量其实是修改这个结构体里面的变量。
但是我们还有个疑惑，__Block_byref_val_0 这个结构体是在栈上创建的，而 Block 是要从栈上拷贝到堆上的（生命周期比函数/方法长），__Block_byref_val_0 是怎么跟随 Block 一起被拷贝到堆上的？
Block 的内存结构
Block 的存储区域
前面的章节里面提到了 _NSConcreteStackBlock ，与之同类的有以下几个：
_NSConcreteStackBlock_NSConcreteGlobalBlock_NSConcreteMallocBlock
它们代表了 Block 不同的存储区域。
存储在 Data 区的 Block —— _NSConcreteGlobalBlock
有两种 Block 会被存放在 Data 区：
- 像全局变量一样，声明在函数外面的 Block：
void (^blk)(void) = ^{printf("Global Block\n");};
int main() {
// ...
}- Block 内部没有捕获局部变量，逻辑与外界独立：
typedef int (^blk_t)(int);
for (int rate = 0; rate < 10; ++rate) {
blk_t blk = ^(int count){
return count;
};
}Data 区的内存在编译时就已确定好，在程序整个运行期间都存在。把数据存储在 Data 区能够减少数据的创建和释放，加快执行以及访问速度。
存储在堆区的 Block —— _NSConcreteMallocBlock
在 Data 区存储的 Block 有着和程序一样长的生命周期，在栈区存储的 Block 会在超出作用域后释放，而存储在堆区的 Block 具备更灵活的生命周期。
Block 提供了从栈区复制到堆区的能力。从栈区复制到堆区后，Block 的 isa 属性值会从 &_NSConcreteMallocBlock 变成 &_NSConcreteMallocBlock：
impl.isa = &_NSConcreteMallocBlock;Block 被拷贝到堆区后，可以通过 __forwarding 属性获取到堆上的 Block。
自动/手动拷贝 Block
在 ARC 环境下，编译器会自动检测并把 Block 从栈区拷贝到堆区，甚至是在创建时就直接把 Block 拷贝到了堆区（因为隐式强持有）。
-fobjc-arc 参数。将下面的代码片段通过 clang 编译执行（注意不是转译，是直接编译执行）：
#include <Foundation/Foundation.h>
typedef int (^blk_t)(int);
blk_t func(int rate) {
blk_t blk = ^(int count){
return rate * count;
};
NSLog(@"blk: %@", blk);
blk_t blk1 = ^(int count){
return rate * count;
};
NSLog(@"blk1: %@", blk1);
return blk1;
}
int main(int argc, const char * argv[]) {
blk_t blk = func(10);
NSLog(@"blk main: %@", blk);
return 0;
}clang -isysroot `xcrun --show-sdk-path` -fno-objc-arc -framework Foundation block_copy.m -o block_copy 编译单个 .m 文件。-fno-objc-arc 和 fobjc-arc 分别控制是否在 ARC 环境下执行。- ARC 执行结果：
2023-10-08 19:15:32.227 block_copy[18722:5025896] blk: <__NSMallocBlock__: 0x6000026f8660>
2023-10-08 19:15:32.227 block_copy[18722:5025896] blk1: <__NSMallocBlock__: 0x6000026fc000>
2023-10-08 19:15:32.228 block_copy[18722:5025896] blk main: <__NSMallocBlock__: 0x6000026fc000>- 非 ARC 执行结果：
2023-10-08 18:57:25.187 block_copy[18054:5000955] blk: <NSStackBlock: 0x16b75f128>
2023-10-08 18:57:25.187 block_copy[18054:5000955] blk1: <NSStackBlock: 0x16b75f0f8>
[1] 18054 segmentation fault ./block_copy在 ARC 环境下，因为局部变量对 Block 是强持有的，所以Blocks 被自动拷贝到了堆区。被拷贝到堆区的 Block 不会在函数执行完毕后释放，因此在 main 函数里赋值没有问题。
而非 ARC 环境下，Blocks 没有被自动拷贝到堆区，还是在栈区。而且由于栈区的 Block 在函数结束后被释放了，因此在 main 函数里接受的返回值是空的，导致程序执行出错。
在 ARC 环境下，大部分 Block 的都被编译器在堆区或者 Data 区初始化。可以说，只要有变量（不管是局部变量还是其他变量）强持有了 Block，那 Block 就不大可能是存在栈区的。而且在 ARC 环境下，变量默认是强持有的，除非用 weak 或 __weak 指定弱持有。
以下面代码为例，调用其中的 testCopy 方法。
- (void)testCopy {
NSArray *arr = [self createBlocks];
typedef void (^blk_t)(void);
blk_t arr_blk = (blk_t)[arr objectAtIndex:0];
NSLog(@"arr_blk: %@", arr_blk);
arr_blk();
__weak blk_t weak_arr_blk = (blk_t)[arr objectAtIndex:1];
NSLog(@"weak_arr_blk: %@", weak_arr_blk);
weak_arr_blk();
int val = 0;
__weak blk_t weak_blk = ^{ NSLog(@"val: %d", val); };
NSLog(@"weak_blk: %@", weak_blk);
blk_t strong_blk = ^{ NSLog(@"val: %d", val); };
NSLog(@"strong_blk: %@", strong_blk);
}
- (id)createBlocks {
int stackValue = 1;
NSLog(@"stack value address: %p", &stackValue);
// __block int val = 10;
int val = 10;
NSLog(@"val address: %p", &val);
return [[NSArray alloc] initWithObjects:^{ NSLog(@"blk0: %d, val pointer: %p", val, &val); }, ^{ NSLog(@"blk1: %d", val); }, nil];
}输出为：
stack value address: 0x16fdff0dc
val address: 0x16fdff0d8
arr_blk: <__NSMallocBlock__: 0x6000012a0000>
blk0: 10, val pointer: 0x6000012a0020
weak_arr_blk: <__NSMallocBlock__: 0x6000012a0030>
blk1: 10
weak_blk: <__NSStackBlock__: 0x16fdff1a0>
strong_blk: <__NSMallocBlock__: 0x6000012a8330>- 通过 NSArray 的 initWithObjects 方法传入的 Block 都变成了 NSMallocBlock，触发了编译器的自动拷贝。这一点和原书中讲述的不一致：原书中说这种作为参数传递给函数或方法的 Block 是 NSStackBlock，且不会出发自动拷贝，会在函数结束后释放，导致后面在数组里取 Block 元素并执行的时候报错。
- Block 类型的变量强持有的 Block 是堆区 Block。由于数组也是强持有 Block，所以数组里面的 Block 元素被拷贝到了堆区
- Block 变量弱持有的 Block 是栈区 Block
另外也可以通过 copy 方法主动将栈区的 Block 拷贝到堆区：
- (void)testStackCopytoHeap {
int val = 0;
typedef void (^blk_t)(void);
__weak blk_t weak_blk = ^{ NSLog(@"val: %d", val); };
NSLog(@"stack_blk: %@", weak_blk);
NSLog(@"heap_blk: %@", [weak_blk copy]);
}输出：
stack_blk: <__NSStackBlock__: 0x16fdff1d8>
heap_blk: <__NSMallocBlock__: 0x600002b243f0>调用 copy 方法后，栈区的 Block 被拷贝到了堆区。
__block 变量的内存区域
前面的部分总结了 Block 由栈区拷贝到堆区的规则。这一小节会总结下由 __block 修饰的变量的内存拷贝原则。
先记住总的原则：当 Block 由栈区拷贝到堆区后，其捕获的 __block 变量也会由栈区拷贝到堆区，拷贝完成后 Block 依旧对 __block 变量有所属权。
拷贝流程：
- 起初假设 Block 和
__block变量都在栈区。 - 当 Block 被拷贝到堆区后，其持有的
__block变量也会被拷贝到堆区。 - 如果是多个 Block 都对
__block变量拥有所属权，__block变量仅会经历一次从栈区拷贝到堆区的操作，不会有从堆区拷贝到堆区的操作。
- Block 释放后，如果不再有 Block 持有
__block变量，那么__block变量将随之释放。
当 __block 变量拷贝到堆区前后，Block 内部使用这个变量时都是通过 __forwarding 来获取当前实际的变量。
__forwarding
__Block_byref_val_0 结构体里面的 __forwarding 属性是为了追踪 __block 变量的实际位置的。如果 __block 变量处于栈区，那么 __forwarding 将是一个指向栈区变量的指针；如果 __block 变量被拷贝到了堆区，那么 __forwarding 将同步变成指向堆区变量的指针。
在上面转译后的源码的 main 函数里，有这样的一段代码：
__attribute__((__blocks__(byref))) __Block_byref_val_0 val = {(void*)0,(__Block_byref_val_0 *)&val, 0, sizeof(__Block_byref_val_0), 10};
void (*blk)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_val_0 *)&val, 570425344));这段代码在栈区创建了一个 __Block_byref_val_0 类型的 val，并将其地址作为参数传递给了 __main_block_impl_0 类型的 blk 变量。虽然说 Block 能通过 (val->__forwarding->val) 来获取到实际的 val，但是当 Block 被拷贝到堆区，函数执行完毕后，栈区的 val 应该会被释放掉，这时候再调用 (val->__forwarding->val) 是如何保证不出现崩溃问题的？
在转译代码中，有 Block 的 copy 和 dispose 函数的实现：
static void __main_block_copy_1(struct __main_block_impl_1*dst, struct __main_block_impl_1*src) {_Block_object_assign((void*)&dst->val, (void*)src->val, 8/*BLOCK_FIELD_IS_BYREF*/);}
static void __main_block_dispose_1(struct __main_block_impl_1*src) {_Block_object_dispose((void*)src->val, 8/*BLOCK_FIELD_IS_BYREF*/);}其中用到了 _Block_object_assign 和 _Block_object_dispose 函数，这两个函数接受的并不是 __main_block_impl_1 类型的参数，而是 __Block_byref_val_0 类型的参数，也就是 __block 变量的底层结构体。
clang 转译的代码中没有说 Block 以及 __block 变量具体是怎么被拷贝的，需要查看关键函数 _Block_object_assign 的实现。源码可以在 libclosure 中的 runtime.c 文件中找到。
//
// When Blocks or Block_byrefs hold objects then their copy routine helpers use this entry point
// to do the assignment.
//
void _Block_object_assign(void *destArg, const void *object, const int flags) {
const void **dest = (const void **)destArg;
switch (flags & BLOCK_ALL_COPY_DISPOSE_FLAGS) {
case BLOCK_FIELD_IS_OBJECT:
/*******
id object = ...;
[^{ object; } copy];
********/
_Block_retain_object(object);
*dest = object;
break;
case BLOCK_FIELD_IS_BLOCK:
/*******
void (^object)(void) = ...;
[^{ object; } copy];
********/
*dest = _Block_copy(object);
break;
case BLOCK_FIELD_IS_BYREF | BLOCK_FIELD_IS_WEAK:
case BLOCK_FIELD_IS_BYREF:
/*******
// copy the onstack __block container to the heap
// Note this __weak is old GC-weak/MRC-unretained.
// ARC-style __weak is handled by the copy helper directly.
__block ... x;
__weak __block ... x;
[^{ x; } copy];
********/
*dest = _Block_byref_copy(object);
break;
case BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_OBJECT:
case BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_BLOCK:
/*******
// copy the actual field held in the __block container
// Note this is MRC unretained __block only.
// ARC retained __block is handled by the copy helper directly.
__block id object;
__block void (^object)(void);
[^{ object; } copy];
********/
*dest = object;
break;
case BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_OBJECT | BLOCK_FIELD_IS_WEAK:
case BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_BLOCK | BLOCK_FIELD_IS_WEAK:
/*******
// copy the actual field held in the __block container
// Note this __weak is old GC-weak/MRC-unretained.
// ARC-style __weak is handled by the copy helper directly.
__weak __block id object;
__weak __block void (^object)(void);
[^{ object; } copy];
********/
*dest = object;
break;
default:
break;
}
}函数里面根据不同的 flag 参数走到了不同的分支，转译代码中用的 flag 是 8/*BLOCK_FIELD_IS_BYREF*/ 。那么接下来会调用 _Block_byref_copy 函数，传递进去的参数是拷贝前的 __Block_byref_val_0。
_Block_byref_copy 函数源码：
// Runtime entry points for maintaining the sharing knowledge of byref data blocks.
// A closure has been copied and its fixup routine is asking us to fix up the reference to the shared byref data
// Closures that aren't copied must still work, so everyone always accesses variables after dereferencing the forwarding ptr.
// We ask if the byref pointer that we know about has already been copied to the heap, and if so, increment and return it.
// Otherwise we need to copy it and update the stack forwarding pointer
static struct Block_byref *_Block_byref_copy(const void *arg) {
struct Block_byref *src = (struct Block_byref *)arg;
if ((src->forwarding->flags & BLOCK_REFCOUNT_MASK) == 0) {
// src points to stack
struct Block_byref *copy = (struct Block_byref *)malloc(src->size);
copy->isa = NULL;
// byref value 4 is logical refcount of 2: one for caller, one for stack
copy->flags = src->flags | BLOCK_BYREF_NEEDS_FREE | 4;
copy->forwarding = copy; // patch heap copy to point to itself
src->forwarding = copy; // patch stack to point to heap copy
copy->size = src->size;
if (src->flags & BLOCK_BYREF_HAS_COPY_DISPOSE) {
// Trust copy helper to copy everything of interest
// If more than one field shows up in a byref block this is wrong XXX
struct Block_byref_2 *src2 = (struct Block_byref_2 *)(src+1);
struct Block_byref_2 *copy2 = (struct Block_byref_2 *)(copy+1);
copy2->byref_keep = src2->byref_keep;
copy2->byref_destroy = src2->byref_destroy;
if (BLOCK_BYREF_LAYOUT(src) == BLOCK_BYREF_LAYOUT_EXTENDED) {
struct Block_byref_3 *src3 = (struct Block_byref_3 *)(src2+1);
struct Block_byref_3 *copy3 = (struct Block_byref_3*)(copy2+1);
copy3->layout = src3->layout;
}
(*src2->byref_keep)(copy, src);
}
else {
// Bitwise copy.
// This copy includes Block_byref_3, if any.
memmove(copy+1, src+1, src->size - sizeof(*src));
}
}
// already copied to heap
else if ((src->forwarding->flags & BLOCK_BYREF_NEEDS_FREE) == BLOCK_BYREF_NEEDS_FREE) {
latching_incr_int(&src->forwarding->flags);
}
return src->forwarding;
}因为 val (这里指的是 __block 变量的底层结构体）在拷贝前是在栈区，所以会走到 if 分支里。如果走到 else if 里面，就说明 val 已经被拷贝到堆区了。随后调用了 malloc 函数，在堆区给新的 val 申请了内存空间。比较关键的是这两行代码：
copy->forwarding = copy; // patch heap copy to point to itself
src->forwarding = copy; // patch stack to point to heap copy这两行代码让堆区新拷贝的和原来栈区没释放的 val 的 __forwarding 都指向了堆区新拷贝的 val 。也就是说，拷贝完成后，通过 __forwarding 获取的 val 肯定是堆区的。
另外还有一个需要注意的地方：
static void __main_block_copy_1(struct __main_block_impl_1*dst, struct __main_block_impl_1*src) {
_Block_object_assign((void*)&dst->val, (void*)src->val, 8/*BLOCK_FIELD_IS_BYREF*/);
}Block 的这个拷贝函数 __main_block_copy_1 调用了 _Block_object_assign 函数，表示 Block 被拷贝到堆区后，会触发将 __block 变量也拷贝到堆区。仔细看这个 _Block_object_assign 函数，里面 dst 取的是地址，src 取的是指针。dst 之所以要取地址，目的就是在 Block 拷贝到堆区后，要把他的 val 成员属性也变成堆区的：
*dest = _Block_byref_copy(object);到这里，前面的疑惑也就解开了。拷贝到堆区的 Block，它的 val 成员变量也会赋值为拷贝到堆区的 val 。所以不存在当栈区变量释放后，堆区的 Block 调用 val 会引起崩溃的问题。
