引言-“毒鸡汤”
一个好的iOS开发，block必不可少，都会用，但是block的底层原理，我们确都是“浅尝辄止”，满足开发就好。人们总说“俗话说”，但是很多俗话说，不都是前人一步一个坑结结实实的踩了，才总结出来的一句话。那么俗话说“逆水行舟，不进则退”，是否也可以用在开发上？我觉得可以。薪水可以变，但是时间不等人。技术深度（广度）应该是至少跑赢时间（可能大盘看多了，收益跑赢大盘这句话就常挂嘴边）。
希望每一位开发者，都应该具备“危机意识”，在有限的时间，学到更多的技术。
话不多说，今天这个文章，是探索block的底层原理。
block 底层结构
【1】普通block
按照我们探索类的内存时，用到的探索方式，首先查看编译成底层c++的代码是怎么样的。 在main.m中设计代码如下：
int main(int argc, const char * argv[]) {
@autoreleasepool {
int a = 1001;
NSString *str = @"百事可乐";
void (^qlBlock)(void) = ^{
NSLog(@"a = %d -- str = %@",a,str);
};
qlBlock();
}
return 0;
}
打开终端，通过xcrun指令将main.m转成main.cpp文件：
xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc main.m -o main.cpp
打开main.cpp，拉到最底下，找到main函数。将括号内的类型转换删除，得到精简代码如下：
int main(int argc, const char * argv[]) {
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
int a = 1001;
NSString *str = (NSString *)&__NSConstantStringImpl__var_folders_wv_3h_d7hqj7zz300r8bmzy6_y00000gn_T_main_2abb7f_mi_0;
// __main_block_impl_0函数
void (*qlBlock)(void) = __main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA, a, str, 570425344);
qlBlock->FuncPtr(qlBlock);
}
return 0;
}
1、void (*qlBlock)(void)赋值为一个函数调用__main_block_impl_0 ()；
2、搜索__main_block_impl_0找到block的底层实际上也是一个结构体，并且__main_block_impl_0 （）是block的构造函数，源码如下：
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
int a; // 将block外部的变量a捕获成为自己的成员变量
NSString *str; // 将block外部的变量str捕获成为自己的成员变量
// 构造函数：
// 参数1、void *fp：传的是函数__main_block_func_0()，该函数就是block的执行代码块 ^{ }，这个fp传给了 FuncPtr，在qlBlock->FuncPtr(qlBlock);中调用
// 参数2、struct __main_block_desc_0 *desc：block的信息结构体
// 参数3、4 外部捕获的变量，a(_a), str(_str) 分别表示_a赋值给a，_str赋值给str
//
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _a, NSString *_str, int flags=0) : a(_a), str(_str) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
3、qlBlock->FuncPtr(qlBlock);调起block，FuncPtr已经在前面的构造函数中赋值为__main_block_func_0 ()函数。因此，此处调的就是这个函数，并把block自己传进去。该block已捕获了外部变量a，str。
【2】外部变量加上 __block关键字
我们将外部变量a和str分别加上__block关键字，并在block执行块中修改a和str，main.m代码设计如下：
int main(int argc, const char * argv[]) {
@autoreleasepool {
__block int a = 1001;
__block NSString *str = @"百事可乐";
void (^qlBlock)(void) = ^{
a = 2002;
str = @"可口可乐";
NSLog(@"a = %d -- str = %@",a,str);
};
qlBlock();
}
return 0;
}
打开终端，通过xcrun指令将main.m转成main.cpp文件：
xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc main.m -o main.cpp
打开main.cpp，拉到最底下，找到main函数。将括号内的类型转换删除，得到精简代码如下：
1、block的结构体
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
__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) { // 将 _a-> __forwarding赋值给a
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
2、main函数
int main(int argc, const char * argv[]) {
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
__Block_byref_a_0 a = {0,&a, 0, sizeof(__Block_byref_a_0), 1001};
// __main_block_impl_0()
void (*qlBlock)(void) = (__main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA, &a, 570425344));
// 调用
qlBlock->FuncPtr)(qlBlock);
}
return 0;
}
3、生成的a结构体
struct __Block_byref_a_0 {
void *__isa;
__Block_byref_a_0 *__forwarding;
int __flags;
int __size;
int a;
};
4、block执行的代码块
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {// 传入block自己
// 获取block生成的并赋值好的a
__Block_byref_a_0 *a = __cself->a; // bound by ref
// 结构体a通过__forwarding获取结构体a内部的成员变量a，并进行修改
(a->__forwarding->a) = 2002;
NSLog((NSString *)&__NSConstantStringImpl__var_folders_wv_3h_d7hqj7zz300r8bmzy6_y00000gn_T_main_6d01e1_mi_0,(a->__forwarding->a));
}
由编译后的源码可知，
1、外部变量加了__block后，block对外部变量的捕获，不再是单纯的生成与之对应的成员变量，而是在内部生成__Block_byref_a_0 *a的结构体指针变量。
2、在main函数中，先将外部的__block int a编译后，生成一个结构体__Block_byref_a_0(其内部如上3、生成的a结构体，该结构体内部生成一个对应的int a，用于接收外部int a的初始值1001，同时将外部int a的地址&a赋值给__forwarding)，初始化赋值代码：__Block_byref_a_0 a = {0,&a, 0, sizeof(__Block_byref_a_0), 1001};
3、到此为止，生成的结构体a的__forwarding为外部int a的地址，
block结构体内部的*a与外部变量a所指向的内存空间是同一个，捕获的外部变量会随着block生成的对应成员变量改变而改变。
block 底层结构小结
1、block的本质是一个结构体；
2、block的定义，是通过block的结构体内部的构造函数，对block内部的impl、desc进行赋值。
3、结构体impl内部有4个成员变量：isa、Flags、Reserved、FuncPtr，在block构造函数赋值时，将isa赋值为默认的NSConcreteStackBlock地址（此为编译阶段，运行时这个isa会赋值成真实类型），FuncPtr 的赋值是定义的block执行代码块。
4、block捕获外部变量，是在block内部生成对应的成员变量，并通过构造函数将捕获的变量赋值给内部生成的成员变量--（值拷贝）。
5、block捕获的外部变量，如果用__block修饰，则不再是将值传给block内部生成的变量，而是将外部变量的地址传给内部成员变量，达到你动我动的效果--（指针拷贝）。
block 源码
1、在苹果官网Source Browser下载libclosure-79，解压打开Blocks工程。
2、在原来的objc工程的main.m中，定一个最简单的block，并打上断点，运行到断点后，打开汇编（Debug--Debug Workflow -- Always Show Disassembly）。
3、在汇编中，查看block的类型，以及将要
call的符号
4、点击
step into，进入到objc_retainBlock函数中，可看到将要访问_Block_copy，此函数即可将 stack block 复制成 malloc block
5、继续点击
step into会回到main的汇编。因此_Block_copy是我们继续探索的函数符号。打开1的Blocks工程。全局搜索_Block_copy，源码如下（注意看注释）：
// Copy, or bump refcount, of a block. If really copying, call the copy helper if present.
void *_Block_copy(const void *arg) {
// block的真实结构Block_layout
struct Block_layout *aBlock;
if (!arg) return NULL;
// The following would be better done as a switch statement
aBlock = (struct Block_layout *)arg;
// 如果是释放状态，没必要进行下一步处理，直接返回aBlock
if (aBlock->flags & BLOCK_NEEDS_FREE) {
// latches on high
latching_incr_int(&aBlock->flags);
return aBlock;
}
else if (aBlock->flags & BLOCK_IS_GLOBAL) {
// 如果是global类型的block，直接返回。
return aBlock;
}
else {
// 如果不是global block，那么只有两种情况：1、栈block（StackBlock），2、堆block(MallocBlock)
// 在编译阶段，暂时会将block标记成栈block，是因为在编译阶段，若是对block进行malloc开辟内存的话，会增加编译器的压力
// 来到运行时（runtime），block捕获了外部变量，则需要将栈block 的大小，malloc(size)开辟一个内存空间
// Its a stack block. Make a copy.
size_t size = Block_size(aBlock);
struct Block_layout *result = (struct Block_layout *)malloc(size);
if (!result) return NULL;
// 开始copy
memmove(result, aBlock, size); // bitcopy first
#if __has_feature(ptrauth_calls)
// Resign the invoke pointer as it uses address authentication.
// invoke的copy
result->invoke = aBlock->invoke;
#if __has_feature(ptrauth_signed_block_descriptors)
if (aBlock->flags & BLOCK_SMALL_DESCRIPTOR) {
uintptr_t oldDesc = ptrauth_blend_discriminator(
&aBlock->descriptor,
_Block_descriptor_ptrauth_discriminator);
uintptr_t newDesc = ptrauth_blend_discriminator(
&result->descriptor,
_Block_descriptor_ptrauth_discriminator);
result->descriptor =
ptrauth_auth_and_resign(aBlock->descriptor,
ptrauth_key_asda, oldDesc,
ptrauth_key_asda, newDesc);
}
#endif
#endif
// reset refcount
// 重置refcount和配置flags
result->flags &= ~(BLOCK_REFCOUNT_MASK|BLOCK_DEALLOCATING); // XXX not needed
result->flags |= BLOCK_NEEDS_FREE | 2; // logical refcount 1
_Block_call_copy_helper(result, aBlock);
// Set isa last so memory analysis tools see a fully-initialized object.
// 将block类型标记为堆block（MallocBlock）
result->isa = _NSConcreteMallocBlock;
return result;
}
}
6、通过源码可知流程如下：
a）oc定义的block 不 捕获外部变量 ---->编译器--->global block---->运行时--->return global block
b）oc定义的block捕获外部变量 ---->编译器--->stack block ---->运行时_Block_copy--->malloc block
7、block的底层结构为struct Block_layout结构体，源码如下（注意注释）：
struct Block_layout {
// isa的指向：也可以说是block的类型：1、global block；2、stack block；3、malloc block
void * __ptrauth_objc_isa_pointer isa;
// 标识
volatile int32_t flags; // contains ref count
int32_t reserved;
// 执行函数
BlockInvokeFunction invoke;
// block的信息描述
struct Block_descriptor_1 *descriptor;
// imported variables
};
- 7.1、结构体
Block_layout的成员变量struct Block_description_1开始，往下都是为可选参数，也就是说，block的描述信息，可以在以下结构体中选择（但是具体如何设置，根据#define条件来配置，在哪儿配置，我们不得而知，然我们可以通过反推法来了解，即不知道setter，通过getter来了解）：
#define BLOCK_DESCRIPTOR_1 1
struct Block_descriptor_1 {
uintptr_t reserved;
uintptr_t size;
};
#define BLOCK_DESCRIPTOR_2 1
struct Block_descriptor_2 {
// requires BLOCK_HAS_COPY_DISPOSE
BlockCopyFunction copy;
BlockDisposeFunction dispose;
};
#define BLOCK_DESCRIPTOR_3 1
struct Block_descriptor_3 {
// requires BLOCK_HAS_SIGNATURE
const char *signature;
const char *layout; // contents depend on BLOCK_HAS_EXTENDED_LAYOUT
};
struct Block_descriptor_small {
uint32_t size;
int32_t signature;
int32_t layout;
/* copy & dispose are optional, only access them if
Block_layout->flags & BLOCK_HAS_COPY_DIPOSE */
int32_t copy;
int32_t dispose;
};
- 7.2 block desc的几种情况
- 7.2.1
Block_descriptor_1：搜索_Block_get_descriptor，源码如下：
// getter 函数
static inline void *_Block_get_descriptor(struct Block_layout *aBlock)
{
void *descriptor;
#if __has_feature(ptrauth_signed_block_descriptors)
if (!(aBlock->flags & BLOCK_SMALL_DESCRIPTOR)) {
descriptor =
(void *)ptrauth_strip(aBlock->descriptor, ptrauth_key_asda);
} else {
uintptr_t disc = ptrauth_blend_discriminator(
&aBlock->descriptor, _Block_descriptor_ptrauth_discriminator);
descriptor = (void *)ptrauth_auth_data(
aBlock->descriptor, ptrauth_key_asda, disc);
}
#elif __has_feature(ptrauth_calls)
descriptor = (void *)ptrauth_strip(aBlock->descriptor, ptrauth_key_asda);
#else
descriptor = (void *)aBlock->descriptor;
#endif
return descriptor;
}
// setter函数
static inline void _Block_set_descriptor(struct Block_layout *aBlock, void *desc)
{
aBlock->descriptor = (struct Block_descriptor_1 *)desc;
}
- 7.2.2
Block_descriptor_2：全局搜索Block_descriptor_2，源码如下（看下图解释）：
static struct Block_descriptor_2 * _Block_descriptor_2(struct Block_layout *aBlock)
{
uint8_t *desc = (uint8_t *)_Block_get_descriptor(aBlock);
desc += sizeof(struct Block_descriptor_1);// 看下图解释
return (struct Block_descriptor_2 *)desc;
}
- 7.2.3
Block_descriptor_3：全局搜索Block_descriptor_3，源码如下（看上图解释）：
若Block_descriptor_2存在，则指针偏移在desc的基础上，加上Block_descriptor_1的大小，再加上Block_descriptor_2的大小，即可得到Block_descriptor_3。（desc3 = desc + sizeOf(desc1) + sizeOf(desc2)）
若Block_descriptor_2不存在，则指针偏移在desc的基础上，加上Block_descriptor_1的大小，即可得到Block_descriptor_3。（desc3 = desc + sizeOf(desc1) ）
static struct Block_descriptor_3 * _Block_descriptor_3(struct Block_layout *aBlock)
{
uint8_t *desc = (uint8_t *)_Block_get_descriptor(aBlock);
desc += sizeof(struct Block_descriptor_1);
if (aBlock->flags & BLOCK_HAS_COPY_DISPOSE) {
desc += sizeof(struct Block_descriptor_2);
}
return (struct Block_descriptor_3 *)desc;
}
block 调试
1、未捕获外部变量：回到objc工程，在main.m添加如下代码，并添加断点：
2、捕获外部变量：
3、添加
_Block_copy符号断点，运行时，先暂时关闭_Block_copy断点，因为在运行时会有一些系统的block会调用此函数进行复制，我们只需要在自定义的block断点停住时，把_Block_copy断点激活即可。打开Debug 汇编。
3.1：我们通过
lldb调试的指令register read读取寄存器的情况（真机的寄存器名字为x0,x1等），最终看到在_Block_copy函数内部的汇编block的类型的变化，对应上面的_Block_copy源码即可。
3.2：继续点击
step over，一直回到main.m时，在block调用处打上断点。通过lldb调试的指令register read读取寄存器的情况，如图所示：
若外部变量为对象，则会多一个
copy和dispose。即7.1中的block信息描述选择。
<__NSStackBlock__: 0x7ffeefbff428>
signature: "v8@?0"
invoke : 0x1000038e0 (/Users/monan/Library/Developer/Xcode/DerivedData/LGProject-dyfiqisfsswhupfyzablyalixxxt/Build/Products/Debug/QLObjcTest`__main_block_invoke)
copy : 0x100003910 (/Users/monan/Library/Developer/Xcode/DerivedData/LGProject-dyfiqisfsswhupfyzablyalixxxt/Build/Products/Debug/QLObjcTest`__copy_helper_block_e8_32s)
dispose : 0x100003950 (/Users/monan/Library/Developer/Xcode/DerivedData/LGProject-dyfiqisfsswhupfyzablyalixxxt/Build/Products/Debug/QLObjcTest`__destroy_helper_block_e8_32s)
3.3：signature的值可参考前面的文章类的方法底层，是一样的。具体例子：lldb调试：[NSMethodSignature signatureWithObjCTypes:"v8@?0"];打印结果如下（注意注释）：
(lldb) po [NSMethodSignature signatureWithObjCTypes:"v8@?0"];
<NSMethodSignature: 0x7afa2cf5db0b894b>
number of arguments = 1
frame size = 224
is special struct return? NO
return value: -------- -------- -------- --------
type encoding (v) 'v'
flags {}
modifiers {}
frame {offset = 0, offset adjust = 0, size = 0, size adjust = 0}
memory {offset = 0, size = 0}
argument 0: -------- -------- -------- --------
type encoding (@) '@?' // 证明了block的encoding类型是`@?`
flags {isObject, isBlock}
modifiers {}
frame {offset = 0, offset adjust = 0, size = 8, size adjust = 0}
memory {offset = 0, size = 8}
block 捕获
【1】无__block修饰
- 1.1 在
main.m中设计代码如下：
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSObject *obj = [NSObject alloc];
void (^ qlBlock)(void) = ^{
NSLog(@"---%@---",obj);
};
qlBlock();
}
return 0;
}
- 1.2 通过
xcrun将源码编译成c/c++。
xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc main.m -o main.cpp
将代码进行排版，清除一些类型强转，简化后的代码如下：
- 1.3 从入口函数main()中可以看到，
^{};最终翻译成函数__main_block_impl_0(),该函数的入参分析： - a）
__main_block_func_0是一个函数指针，是block回调执行的代码块 - b）（重点）
&__main_block_desc_0_DATA是取结构体__main_block_desc_0的地址，该结构体赋值情况，即：
__main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0), __main_block_copy_0, __main_block_dispose_0};
具体对应的变量为：
size_t reserved = 0;
size_t Block_size = sizeof(struct __main_block_impl_0);
void (copy)(struct __main_block_impl_0, struct __main_block_impl_0) = __main_block_copy_0;
void (dispose)(struct __main_block_impl_0*) = __main_block_dispose_0;
- c）
obj即我们定义的obj变量，obj作为参数传入block内部生成的obj变量，并将外部obj赋值给内部obj。由于obj是一个NSObject *的指针，此处obj传入相当于block生成的obj与外部的obj指向同一片堆空间。（block捕获外部变量的小结在上面的block 底层结构小结） - d）
570425344数字参数，是一个暂时用不到的参数。暂不考虑。
【2】有__block修饰
我们在NSObject *obj前加入__block，然后 按照第【1】步的步骤，将main.m编译成c/c++。
将代码进行排版，清除一些类型强转，简化后的代码如下：
- 2.1 与前面的
无 __block 修饰的外部变量捕获相比，加了__block后，外部变量NSObject *obj逻辑编译成了一个结构体__Block_byref_obj_0 obj，该结构体源码如下： - 2.2 用
__block修饰的外部遍历，block构造函数__main_block_impl_0传入的是&obj，也就是obj本身的地址，也就是说，外部的obj随着block内部的obj的变化而变化。 - 2.3
无__block修饰的外部变量，block构造函数__main_block_impl_0传入的是obj，也就是obj指针指向的堆地址。
【3】_Block_object_assign
- 【3.1】 通过上面将block编译成c/c++文件的分析。我们可以看到在封装
block信息描述的结构体desc中，传入了一__main_block_copy_0函数和一个__main_block_dispose_0函数。两个函数的实现如下：
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {
_Block_object_assign(&dst->obj, src->obj, 8/*BLOCK_FIELD_IS_BYREF*/);
}
static void __main_block_dispose_0(struct __main_block_impl_0*src) {
_Block_object_dispose(src->obj, 8/*BLOCK_FIELD_IS_BYREF*/);
}
_Block_object_assign()传入了三个参数：1、&dst->obj：目标block的obj地址；2、src->obj：原block的obj变量；3、8：BLOCK_FIELD_IS_BYREF，表示该对象用__block 修饰了。
The flags parameter of _Block_object_assign and _Block_object_dispose is set to
* BLOCK_FIELD_IS_OBJECT (3), for the case of an Objective-C Object,
* BLOCK_FIELD_IS_BLOCK (7), for the case of another Block, and
* BLOCK_FIELD_IS_BYREF (8), for the case of a __block variable.
即：
- 捕获的外部变量为
普通oc对象，则传入3；- 捕获的外部变量为
其他block，则传入7；- 捕获的外部变量为
用__block修饰的变量，则传入8；
- 【3.2】 打开
Blocks.xcodeproj工程，全局搜索_Block_object_assign，找到源码如下：
void _Block_object_assign(void *destArg, const void *object, const int flags) {
const void **dest = (const void **)destArg;
switch (os_assumes(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;
}
}
分析：
通过flags & BLOCK_ALL_COPY_DISPOSE_FLAGS得到捕获的变量是什么类型，通过switch分支进行分类处理。
- 3.2.1
case BLOCK_FIELD_IS_OBJECT:如果捕获的变量是oc object ，则将捕获的object进行copy。（通过_Block_retain_object()回调给_Block_retain_object_default()，并将原block赋值给目标block*dest = object;） - 3.2.2
case BLOCK_FIELD_IS_BLOCK:如果捕获的对象是一个block，则走_Block_copy()函数，并将结果赋值给目标block。 - 3.2.3（后面重点分析）
case BLOCK_FIELD_IS_BYREF :如果捕获的变量是用__block修饰的或者__weak __block修饰的，将原block通过_Block_byref_copy()赋值给目标block。 - 3.2.4
其余情况均是将原block直接赋值给目标block：*dest = object;
【4】_Block_byref_copy
全局搜索_Block_byref_copy，得到源码如下：
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 (src->flags & 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;
}
- 【4.1】判断语句
if ((src->forwarding->flags & BLOCK_REFCOUNT_MASK) == 0)，其中BLOCK_REFCOUNT_MASK为引用计数相关的掩码。如果此处判断 == 0，说明引用计数为0，并没有将block copy到堆上。反之(src->forwarding->flags & BLOCK_REFCOUNT_MASK) != 0，则说明已经将原block copy到堆上。接着判断flags是否需要释放，需要释放则进行flags的重新赋值。
-【4.2】未copy到堆上，流程如图所示：
-【4.3】判断语句if (src->flags & BLOCK_BYREF_HAS_COPY_DISPOSE)如果成立，说明已经捕获到了外部变量，具体如图所示：
【5】byref_keep
由上图我们可知byref_keep()是为了保存（保活）外部捕获变量的生命周期，如果不进行keep，则有可能会出现src为空了之后，开辟的空间的内容也被清空了。
byref_keep的源码为：
struct Block_byref_2 {
// requires BLOCK_BYREF_HAS_COPY_DISPOSE
BlockByrefKeepFunction byref_keep;
BlockByrefDestroyFunction byref_destroy;
};
返回到main_byref.cpp文件中，找到struct __Block_byref_obj_0{}结构体，内部的copy和dispose函数分别赋值给了byref_keep和byref_destroy。也就是说在编译后的cpp文件中，在main函数里，__block修饰的NSObject *obj，编译所生成的结构体的赋值，__Block_byref_id_object_copy_131赋值给了结构体__Block_byref_obj_0的copy函数；__Block_byref_id_object_dispose_131赋值给了__Block_byref_obj_0的dispose函数。
也就是说：
byref_keep = __Block_byref_id_object_copy_131函数
byref_destroy = __Block_byref_id_object_dispose_131函数
由此可知，byref_keep函数的调用，是调用__Block_byref_obj_0的copy函数。也就是把_Block_object_assign调用一遍，即
// (*src2->byref_keep)(copy, src);
static void __Block_byref_id_object_copy_131(void *dst, void *src) {
_Block_object_assign(dst + 40, * (src + 40), 131);
}
- a）
dst：即byref_keep函数的第1个参数copy：新开辟的block（目标block）。 - b）
src：即byref_keep函数的第2个参数src：原来的block。 - c）
dst+40、src + 40，是在目标block的首地址平移40字节，对应结构体__Block_byref_obj_0内存结构，平移40字节，得到的是NSObject *obj，计算方式如下：
struct __Block_byref_obj_0 {
void *__isa; // 8
__Block_byref_obj_0 *__forwarding;// 8
int __flags; // 4
int __size; // 4
void (*__Block_byref_id_object_copy)(void*, void*);// 8
void (*__Block_byref_id_object_dispose)(void*);// 8
NSObject *obj;
};
则_Block_object_assign(dst + 40, * (src + 40), 131);变成为_Block_object_assign(obj, * obj, 131);。由上面_Block_object_assign函数的源码可知，此刻的switch分支，走的就是BLOCK_FIELD_IS_OBJECT分支。
因此，block捕获__block修饰的外部变量，
总结
- block的本质是一个
结构体，并由结构体的构造函数初始化和赋值。 - block的类型有
3种，global block，stack block，malloc block。 - block
不捕获外部变量则为global block。 - block
捕获外部变量则编译时为stack block，运行时_Block_copy后变成malloc block。 - 结构体impl内部有4个成员变量：isa、Flags、Reserved、FuncPtr，在block构造函数赋值时，将isa赋值为默认的NSConcreteStackBlock地址（此为编译阶段，运行时这个isa会赋值成真实类型），FuncPtr 的赋值是定义的block执行代码块。
- block结构体中的
Block_descriptor_1和Block_byref一样内存是连续的可通过指针平移来获取对应位置的值。
Block_descriptor_1---Block_descriptor_2---Block_descriptor_3内存是连续的，
Block_byref---Block_byref_2---Block_byref_3内存是连续的 - block捕获外部变量，是在block内部生成对应的成员变量，并通过构造函数将捕获的变量赋值给内部生成的成员变量 --
（值拷贝）。 - 捕获用
__block修饰的外部变量（指针拷贝）3层copy：
（a）将block从栈copy到堆上
（b）接着block捕获Block_byref结构体，并对其进行copy
（c）Block_byref对内部的变量（本文为NSObject *obj）进行copy。
