前言
iOS-深入研究Block这篇文章结合实例介绍了Block的类型，循环引用等问题，接着我们通过Block的源码分析一下，它的底层是怎么操作的？
1 通过Clang分析Block
Block通过Clang将会编译成什么样的结构呢，它的invoke，isa，签名的原理是什么，我们来研究下。
#include "stdio.h"
int main(){
// __Block_byref_a_0 int a = 18;
int a = 8;
void(^block)(void) = ^{
// a++;
printf("ro_robert - %d",a);
};
block();
return 0;
}
我们通过xcrun -sdk iphonesimulator clang -S -rewrite-objc -fobjc-arc -fobjc-runtime=ios-14.5 block.c命令执行一个得到block.cpp文件.
我们打开block.cpp文件，找到main函数，如下
int main(){
int a = 8;
void(*block)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, a));
((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
return 0;
}
static struct IMAGE_INFO { unsigned version; unsigned flag; } _OBJC_IMAGE_INFO = { 0, 2 };
从上可以看出，我们要研究的 void(*block)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, a));*是这行代码。
我们经过调整下，如下
void(*block)(void) = __main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA, a));
void(*block)(void) 这是一个函数指针，
这里的__main_block_impl_0就是一个函数调用。
((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
把这行也调下，如下所示
block->FuncPtr(block);
我们先看下__main_block_impl_0这个是什么，经过搜下，如下
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
int a;
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _a, int flags=0) : a(_a) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
这是一个结构体，
void(*block)(void) = __main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA, a));
就是这个结构体的构造函数，传了三个参数，其中有一个我们传的参数是a，这个__main_block_impl_0这个结构体中也有一个变量a，他们有什么关系呢，我们来看下。
我们在block.c中把这个变量a去掉，看下是什么效果。
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;
}
};
这个就是现在__main_block_impl_0结构体，我们发现这里的没有a这个变量了，它的构造函数同样也没有a这个参数。
我们再来看下之前的结构体的构造函数
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _a, int flags=0) : a(_a) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
这里: a(_a) 是C++语法，默认会对传过来的参数a赋值，_a会传给a,说白了就是赋值操作，block在底层会把变量捕获进来，变成自己的成员变量。
我们通过真实的App代码，如下
- (void)viewDidLoad {
[super viewDidLoad];
NSObject *objc = [NSObject alloc];
__block NSObject *objc1 = [NSObject alloc];
void (^block1)(void) = ^{
NSLog(@"ro_Block %@ ",objc1);
};
block1();
}
我们打开ViewController.cpp文件，找到__ViewController__viewDidLoad_block_impl_0这个结构体，如下
struct __ViewController__viewDidLoad_block_impl_0 {
struct __block_impl impl;
struct __ViewController__viewDidLoad_block_desc_0* Desc;
NSObject *__strong objc1;
__ViewController__viewDidLoad_block_impl_0(void *fp, struct __ViewController__viewDidLoad_block_desc_0 *desc, NSObject *__strong _objc1, int flags=0) : objc1(_objc1) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
这里面有一个NSObject *__strong objc1;对象，这说明我们的Block在捕获取变量时会生成相应的成员变量。
在编译价段，impl.isa = &_NSConcreteStackBlock;这里是一个stackBlock;。
之前我们介绍过，捕获局部或者属性变量，又不是弱引用，应该是这个MallocBlock，为什么这里是StatckBlock，我们来看下。
在这里我们是在编译时是StackBlock，程序还要经过运行时，才会变成堆，是如何变成堆呢，需要我们再研究下。
这里有一个fp参数，是第一个参数，经过查找，它是__ViewController__viewDidLoad_block_func_0，而它又是这个
static void __ViewController__viewDidLoad_block_func_0(struct __ViewController__viewDidLoad_block_impl_0 *__cself) {
NSObject *__strong objc1 = __cself->objc1; // bound by copy
NSLog((NSString *)&__NSConstantStringImpl__var_folders_r7_rnm6hs1x2jg8bqy7sjwsskx00000gn_T_ViewController_2b1512_mi_0,objc1);
}
函数，就是传一个函数过去，之后进行了FuncPtr的执行，就是去执行__ViewController__viewDidLoad_block_func_0这个函数，就是运行起来。
block函数式保存，如果不调用执行，永远也没可能执行它的功能逻辑。
我们切换到block.c代码中，为了防止干扰。
#include "stdio.h"
int main(){
// __Block_byref_a_0 int a = 18;
int a = 18;
void(^block)(void) = ^{
// a++;
printf("ro_robert - %d",a);
// printf("ro_robert");
};
block();
return 0;
}
通过命令编成cpp，我们看下__main_block_func_0
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
int a = __cself->a; // bound by copy
printf("ro_robert - %d",a);
}
这里csef就是传过来的就是自己，
int a = __cself->a;这里的int a 与 __cself->a，就是赋值操作，内容相同，但是地址不同，说白就是值拷贝。
接下来，我们把int a加上__block看下效果，代码如下
#include "stdio.h"
int main(){
// __Block_byref_a_0 int a = 18;
__block int a = 18;
void(^block)(void) = ^{
a++;
printf("ro_robert - %d",a);
// printf("ro_robert");
};
block();
return 0;
}
再次编译，我们再分析下__block做了什么操作？
我们看下__main_block_impl_0的结构体
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) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
我们发现int a 变成 *__Block_byref_a_0 a;
我们再下main函数
int main(){
__attribute__((__blocks__(byref))) __Block_byref_a_0 a = {(void*)0,(__Block_byref_a_0 *)&a, 0, sizeof(__Block_byref_a_0), 18};
void(*block)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_a_0 *)&a, 570425344));
((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
return 0;
}
经过整理，如下
int main(){
__Block_byref_a_0 a = {(void*)0,
(__Block_byref_a_0 *)&a,
0,
sizeof(__Block_byref_a_0),
18};
void(*block)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_a_0 *)&a, 570425344));
((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
return 0;
}
这里__Block_byref_a_0结构体初始化，* (__Block_byref_a_0 )&a,这里取a的地址。
struct __Block_byref_a_0 {
void *__isa;
__Block_byref_a_0 *__forwarding;
int __flags;
int __size;
int a;
};
这里是__Block_byref_a_0这个结构体，__forwarding这里指向a的地址，在这个__main_block_impl_0结构体中把__forwarding传给了参数a，在__main_block_func_0这个函数中
__Block_byref_a_0 *a = __cself->a;
这里的__cself->a;与外界的a是一样的，指向同一块内存区域，说明的就是指针拷贝。
__block生成的__Block_byref_a_0这样的结构体，传给的block的是指针地址，这就是为什么加了__block可以修改外部变量。
2 Block的签名和copy过程
我们在block.cpp文件发现__main_block_copy_0，__main_block_dispose_0，__main_block_desc_0这些结构体，他们是干什么用的呢，我们来分析下block的copy过程。
我们通过断点，分析下汇编流程，调试代码如下
- (void)viewDidLoad {
[super viewDidLoad];
NSObject *objc = [NSObject alloc];
NSObject *objc1 = [NSObject alloc];
void (^block1)(void) = ^{
NSLog(@"robert_Block %@ ",objc1);
};
block1();
}
我们在block打断点，调试，如下
这里调用了objc_retainBlock函数，走进这个函数（也可以通过符号断点），发现调用了_Block_copy这个函数，通过符号断点，是在libsystem_blocks.dylib中，这个是没有开源的，我们找替找工程libclosure(这里用79版本)，可以查看到，我们看下它的源码，如下
void *_Block_copy(const void *arg) {
struct Block_layout *aBlock;
if (!arg) return NULL;
// The following would be better done as a switch statement
aBlock = (struct Block_layout *)arg;
if (aBlock->flags & BLOCK_NEEDS_FREE) {
// latches on high
latching_incr_int(&aBlock->flags);
return aBlock;
}
else if (aBlock->flags & BLOCK_IS_GLOBAL) {
return aBlock;
}
else {// 栈 - 堆 (编译期)
// 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;
memmove(result, aBlock, size); // bitcopy first
#if __has_feature(ptrauth_calls)
// Resign the invoke pointer as it uses address authentication.
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
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.
result->isa = _NSConcreteMallocBlock;
return result;
}
}
我们知道Block是一个结构体，struct Block_layout *aBlock;是Block_layout类型的，它的源码如下
struct Block_layout {
void * __ptrauth_objc_isa_pointer isa;
volatile int32_t flags; // contains ref count
int32_t reserved;
BlockInvokeFunction invoke;
struct Block_descriptor_1 *descriptor;
// imported variables
};
- 这里面有isa指针
- flags标识
- invoke调用函数
- descriptor其它相关描述，是否正在析构等。
这个flags标识符的定义有
// Values for Block_layout->flags to describe block objects
enum {
BLOCK_DEALLOCATING = (0x0001), // runtime 正在析构
BLOCK_REFCOUNT_MASK = (0xfffe), // runtime 掩码
BLOCK_INLINE_LAYOUT_STRING = (1 << 21), // compiler
#if BLOCK_SMALL_DESCRIPTOR_SUPPORTED
BLOCK_SMALL_DESCRIPTOR = (1 << 22), // compiler
#endif
BLOCK_IS_NOESCAPE = (1 << 23), // compiler
BLOCK_NEEDS_FREE = (1 << 24), // runtime
BLOCK_HAS_COPY_DISPOSE = (1 << 25), // compiler
BLOCK_HAS_CTOR = (1 << 26), // compiler: helpers have C++ code
BLOCK_IS_GC = (1 << 27), // runtime
BLOCK_IS_GLOBAL = (1 << 28), // compiler
BLOCK_USE_STRET = (1 << 29), // compiler: undefined if !BLOCK_HAS_SIGNATURE
BLOCK_HAS_SIGNATURE = (1 << 30), // compiler 签名
BLOCK_HAS_EXTENDED_LAYOUT=(1 << 31) // compiler
};
我们对_Block_copy符号断点，然后通命令查看，如图
这是一个全局block。我们再改下代码，让这个block捕获外部变量，如图
这是一个stackBlock，这个block应该是MallocBlock，因为这里还没有经过copy操作，当我们执行完copy操作后，如图
这里成为了MallocBlock，我们再看上面_Block_copy的源码，
*aBlock = (struct Block_layout *)arg;*
这里转换Block_layout类型。
if (aBlock->flags & BLOCK_NEEDS_FREE) {
// latches on high
latching_incr_int(&aBlock->flags);
return aBlock;
}
这是是引用计数据相关处理。
else if (aBlock->flags & BLOCK_IS_GLOBAL) {
return aBlock;
}
如果是GlobalBlock直接返回。
经过编译期过来的是不能生成堆的，当发现是一个stackBlock，又捕获了外界变量，
size_t size = Block_size(aBlock);
struct Block_layout *result = (struct Block_layout *)malloc(size);
这里就会根据原来的大小，就会开辟一段内存空间，然后把原始的数据拷贝到新的Block_layout中，isa指针标记为_NSConcreteMallocBlock,这里就变成了堆Block。
上图中所示的invoke是函数调用者，signatrue就是Block的签名。
signatrue的解释 v8@?0 v代表返回值，8代表8字节， @?代表Block类型，0代表从0号位置开始
3 Blocklayout的结构
当我们invoke的时候，这个消息会失效或有问题，会进入消息转发流程，在最后慢速转发流程时，必须要获取签名才能进行invocation.
我再次看下blocklayout的结构体
struct Block_layout {
void * __ptrauth_objc_isa_pointer isa;
volatile int32_t flags; // contains ref count
int32_t reserved;
BlockInvokeFunction invoke;
struct Block_descriptor_1 *descriptor;
// imported variables
};
我们看下descriptor这个类型，如下
#define BLOCK_DESCRIPTOR_1 1
struct Block_descriptor_1 {
uintptr_t reserved;
uintptr_t size; // 大小
};
descriptor是可选参数，内存连续可选，因为我们的类型不一样，所以结构也不一样，因为有stackBlock,MallocBlock,GlobalBlock的区分，每个类型的结构体不一样，通过标识符判断。
我们在源码找到
#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
};
这些结构体，这些都是通过标识符号来判断。
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;
}
这里通过内存平移来获取到Block_descriptor_2，我们分析下。
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_descriptor_2，有的话，再加上Block_descriptor_2的大小就是Block_descriptor_3的起始位置。
我们看下Block_descriptor_3的结构，如
struct Block_descriptor_3 {
// requires BLOCK_HAS_SIGNATURE
const char *signature;
const char *layout; // contents depend on BLOCK_HAS_EXTENDED_LAYOUT
};
这里有signature，只要有signature的打印，就说明肯定有Block_descriptor_3，我们可以通过x/6gx命令，查看内存。
4 Block的捕获变量生命周期
Block捕获变量时都做了哪些操作，_Block_copy这个函数做了什么？带着这些疑问，我们继续分析底层原理。
我们先看下ViewController.cpp文件，在文件中搜索__ViewController__viewDidLoad_block_desc_0，这个函数，源码如下
static struct __ViewController__viewDidLoad_block_desc_0 {
size_t reserved;
size_t Block_size;
void (*copy)(struct __ViewController__viewDidLoad_block_impl_0*, struct __ViewController__viewDidLoad_block_impl_0*);
void (*dispose)(struct __ViewController__viewDidLoad_block_impl_0*);
} __ViewController__viewDidLoad_block_desc_0_DATA = { 0, sizeof(struct __ViewController__viewDidLoad_block_impl_0), __ViewController__viewDidLoad_block_copy_0, __ViewController__viewDidLoad_block_dispose_0};
这里copy和dispose两个函数，__ViewController__viewDidLoad_block_dispose_0这个就是 Block_descriptor_2中的dispose，__ViewController__viewDidLoad_block_copy_0是_Block_copy函数的指针，它做了什么事情呢，我们来看下，__ViewController__viewDidLoad_block_copy_0这个函数里面会调用_Block_object_assign这个函数，相当于copy函数。
我们继续分析_Block_object_assign，看看它的操作流程， 我们在源码中搜下_Block_object_assign*这个函数，如下
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, // 普通object对象，未使用__block修饰的
* BLOCK_FIELD_IS_BLOCK (7), for the case of another Block, and
* BLOCK_FIELD_IS_BYREF (8), for the case of a __block variable.对应__block修饰
If the __block variable is marked weak the compiler also or's in BLOCK_FIELD_IS_WEAK (16)
这里是三个标识符号，捕获变量的判断和相应处理。我们看下_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_default = fn (arc)
_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;
}
}
如果是BLOCK_FIELD_IS_OBJECT普通对象类型，执行
_Block_retain_object(object);
*dest = object;
_Block_retain_object调用了_Block_retain_object_default，这个函数空实现，默认交给系统级别的ARC操作。
对象账值给目标dest，具备相同的内存空间。
BLOCK_FIELD_IS_BLOCK Block类型，执行
*dest = _Block_copy(object);
_Block_copy调用。
BLOCK_FIELD_IS_BYREF类型，执行
*dest = _Block_byref_copy(object);
_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;
}
- if ((src->forwarding->flags & BLOCK_REFCOUNT_MASK) == 0) 引用计数相关的处理，
arc自己找。
struct Block_byref *copy = (struct Block_byref )malloc(src->size);这里copy一份
copy->isa = NULL;为空。
copy->flags = src->flags | BLOCK_BYREF_NEEDS_FREE | 4; 标识符赋值
copy->forwarding = copy; forwarding拷贝一份
src->forwarding = copy;copy赋给原始的forwarding，这说明原来的forwarding和copy后的forwarding是同一个，都是栈到堆，forwarding传给了objc1这个对象。
if (src->flags & BLOCK_BYREF_HAS_COPY_DISPOSE)这里判断BLOCK_BYREF_HAS_COPY_DISPOSE*被捕获的变量进到这个判断里面。
接着执行
copy2->byref_keep = src2->byref_keep;
copy2->byref_destroy = src2->byref_destroy;
原始对象与copy对象一样。
(*src2->byref_keep)(copy, src);
这里byref_keep进行调用，我们捕获取外界的变量，对它进行相关内存的处理，赋值操作，我们看下byref_keep源码
struct Block_byref_2 {
// requires BLOCK_BYREF_HAS_COPY_DISPOSE
BlockByrefKeepFunction byref_keep;
BlockByrefDestroyFunction byref_destroy;
};
对外界变量生命周期的保存，如果外界的变量变为nil了，block内部的变量也成为nil了。
byref_keep相当于copy函数，
byref_destroy相当于dipose函数
最后调用的就是_Block_object_assign这个函数，在ViewController.cpp中搜下这个函数，找到如下代码
static void __Block_byref_id_object_copy_131(void *dst, void *src) {
_Block_object_assign((char*)dst + 40, *(void * *) ((char*)src + 40), 131);
}
dst + 40就是copy，我们内部的变量，也是Block_byref类型，占用24字节，Block_byref_2占用16字节，刚好这里就是Block_byref_3这个结构体。
struct Block_byref_3 {
// requires BLOCK_BYREF_LAYOUT_EXTENDED
const char *layout;
};
这是Block_byref_3的结构体，这里相当于传的是object1这个对象。
__block修饰的变量流程
- copy，从栈拷贝到栈上
- block捕获变量 _Block_byref类型
- 对_Block_byref对象进行一次copy操作
- 针对_Block_byref里面修饰的object进行copy操作
- byref_keep调用这个函数把里面的对象保存一下
- 释放调用_Block_object_dispose这个函数
void _Block_object_dispose(const void *object, const int flags) {
switch (os_assumes(flags & BLOCK_ALL_COPY_DISPOSE_FLAGS)) {
case BLOCK_FIELD_IS_BYREF | BLOCK_FIELD_IS_WEAK:
case BLOCK_FIELD_IS_BYREF:
// get rid of the __block data structure held in a Block
_Block_byref_release(object);
break;
case BLOCK_FIELD_IS_BLOCK:
_Block_release(object);
break;
case BLOCK_FIELD_IS_OBJECT:
_Block_release_object(object);
break;
case BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_OBJECT:
case BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_BLOCK:
case BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_OBJECT | BLOCK_FIELD_IS_WEAK:
case BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_BLOCK | BLOCK_FIELD_IS_WEAK:
break;
default:
break;
}
}
这里_Block_object_dispose函数的源码
- BLOCK_FIELD_IS_OBJECT普通对象，执行
_Block_release_object(object);
调用_Block_release_object_default这个函数，空实现
- BLOCK_FIELD_IS_BLOCK如果是Block类型，执行
_Block_release(object);
_Block_release的源码
void _Block_release(const void *arg) {
struct Block_layout *aBlock = (struct Block_layout *)arg;
if (!aBlock) return;
if (aBlock->flags & BLOCK_IS_GLOBAL) return;
if (! (aBlock->flags & BLOCK_NEEDS_FREE)) return;
if (latching_decr_int_should_deallocate(&aBlock->flags)) {
_Block_call_dispose_helper(aBlock);
_Block_destructInstance(aBlock);
free(aBlock);
}
}
_Block_destructInstance销毁实例对象， free(aBlock);释放block。
- BLOCK_FIELD_IS_BYREF byref类型（被_block捕获的类型），执行
_Block_byref_release(object);
_Block_byref_release的源码
static void _Block_byref_release(const void *arg) {
struct Block_byref *byref = (struct Block_byref *)arg;
// dereference the forwarding pointer since the compiler isn't doing this anymore (ever?)
byref = byref->forwarding;
if (byref->flags & BLOCK_BYREF_NEEDS_FREE) {
int32_t refcount = byref->flags & BLOCK_REFCOUNT_MASK;
os_assert(refcount);
if (latching_decr_int_should_deallocate(&byref->flags)) {
if (byref->flags & BLOCK_BYREF_HAS_COPY_DISPOSE) {
struct Block_byref_2 *byref2 = (struct Block_byref_2 *)(byref+1);
(*byref2->byref_destroy)(byref);
}
free(byref);
}
}
}
这里调用了byref_destroy这个函数，free(byref);释放byref这个变量，byref里面的对象也会释放。
else if ((src->forwarding->flags & BLOCK_BYREF_NEEDS_FREE) == BLOCK_BYREF_NEEDS_FREE) {
latching_incr_int(&src->forwarding->flags);
}如果不是正常对象 latching_incr_int执行这个函数，自己处理。
总结
这篇文章我们通过源码分析了Block的底层是如何工作的，它的copy流程，释放流程，捕获对象做了比较详细的分析。通过这篇文章我们对Block的底层有了很深层次的认识，有疑问，欢迎大家随时来交流学习。
