Block底层原理
Block底层数据结构
声明一个block
void (^block)(int, int) = ^(int a , int b){
};
通过xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc main.m -o main-arm64.cpp编译成C++代码,简化为下面的代码
struct __main_block_desc_0 {
size_t reserved;
size_t Block_size;
};
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;
};
发现block本质也是一个OC对象，它内部也有isa指针
block是封装了函数调用以及函数调用环境的OC对象。
block执行执行逻辑
void (^block)(void) = ^{
NSLog(@"Hello, World!");
};
block();
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
// 构造函数（类似于OC的init方法），返回结构体对象
__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_2r__m13fp2x2n9dvlr8d68yry500000gn_T_main_c60393_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[]) {
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
// 定义block变量
void (*block)(void) = &__main_block_impl_0(
__main_block_func_0,
&__main_block_desc_0_DATA
);
将__main_block_func_0函数地址 通过__main_block_impl_0构造函数赋值给了FuncPtr，__main_block_impl_0封装了block执行的函数
// 执行block内部的代码
block->FuncPtr(block);
}
return 0;
}
Block变量捕获
可分为局部变量（又分为auto变量，和static变量），全局变量
int age_ = 10;
static int height_ = 10;
void (^block)(void);
void test()
{
//默认是auto:自动变量，离开作用域就销毁
auto int a = 10;
static int b = 10;
block = ^{
NSLog(@"age = %d, height = %d, a = %d, b = %d", age_, height_,a,b);
};
a = 20;
b = 20;
age_ = 20;
height_ = 20;
//结果age = 20, height = 20, a = 10, b = 20
}
int main(int argc, const char * argv[]) {
@autoreleasepool {
test();
block();
}
return 0;
}
编译成底层代码为
int age_ = 10;
static int height_ = 10;
struct __test_block_impl_0 {
struct __block_impl impl;
struct __test_block_desc_0* Desc;
int a; // 数值
int *b; // 指针
__test_block_impl_0(void *fp, struct __test_block_desc_0 *desc, int _a, int *_b, int flags=0) : a(_a), b(_b) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
void test()
{
auto int a = 10;
static int b = 10;
block = ((void (*)())&__test_block_impl_0((void *)__test_block_func_0, &__test_block_desc_0_DATA, a, &b));
a = 20;
b = 20;
age_ = 20;
height_ = 20;
}
// block 执行代码
static void __test_block_func_0(struct __test_block_impl_0 *__cself) {
int a = __cself->a; // bound by copy
int *b = __cself->b; // bound by copy
NSLog((NSString *)&__NSConstantStringImpl__var_folders_l4_53j9g79j49s6l4zzsk30ym7r0000gn_T_main_c4abf1_mi_0, age_, height_,a,(*b));
}
// 可以发现
1、block 初始化的时候，局部变量 a的值是直接传入到block 内部，然后，&b是传入的指针
2、全局变量age_,和height_,没有被传入到block内容，使用的时候是直接访问的
所以age_，height_ 和 b都能修改，a修改失败
3、这样设计的原因是因为，
】局部auto变量的作用域就是test方法内，生命周期也是，超过方法就会被释放，但是block底层是在另外一个函数使用a的，所以需要捕获到blcok内部，
】b是因为通过static修饰，虽然作用域也是test方法，但是生命周期是整个程序，所以在block执行函数里面，只需要捕获指针，然后通过指针访问就可以
】至于全局变量，作用域是全局的，在__test_block_func_0可以直接访问到，所以不需要捕获
block的类型以及存储区域
Snip20200708_6.png
在ARC环境下，编译器会根据情况自动将栈上的block复制到堆上，比如以下情况
1、block作为函数返回值时
typedef void (^LQBlock)(void);
LQBlock myblock()
{
int a = 10;
return ^{
NSLog(@"---------%d",a);
};
}
2、将block赋值给__strong指针时
int age = 10;
LQBlock block = ^{
NSLog(@"---------%d", age);
};
3、block作为Cocoa API中方法名含有usingBlock的方法参数时
[array enumerateObjectsUsingBlock:^(id _Nonnull obj, NSUInteger idx, BOOL * _Nonnull stop) {
}];
4、block作为GCD API的方法参数时
dispatch_async(dispatch_queue_t _Nonnull queue, ^{
<#code#>
});
_block
_block可以用于解决block内部无法修改auto变量值的问题
_block不能修饰全局变量、静态变量（static）
编译器会将_block变量包装成一个对象
__block int age = 10;
MJBlock block = ^{
age = 20;
NSLog(@"age is %d", age);
};
编译成C++
struct __Block_byref_age_0 {
void *__isa;
struct __Block_byref_age_0 *__forwarding;
int __flags;
int __size;
int age;
};
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
struct __Block_byref_age_0 *age; // _block包装成的对象
};
内部修改age的代码
__Block_byref_age_0 *age = __cself->age; // bound by ref
(age->__forwarding->age) = 20;
发现修改age是通过先指向forwarding再指向age修改的，原因是，
block 一开始是在栈上的__forwarding指向栈上的自己，但是当block被拷贝到堆上时堆上的__block结构体内部的__forwarding指向自己，但是栈上的__forwarding 也指向堆上的__block 结构体。当我们修改age时候肯定希望把修改的值放到堆上，所以通过__forwarding第一个age即使是在栈上的，最终也是修改的堆上的age。
Snip20200709_8.png
