_我们先通过一个小场景,开始今天的主题.
有过开发经验的同学都知道,在block内部是无法修改局部变量的,为什么不能修改呢?我们从底层一探究竟,我们把这段代码转成
C++ ,查看一下底层:
如图所示,是无法修改的,那怎么样才能在
block内部修改外部变量呢?有三种方法:
1:使用
static修饰age
2:把
age变成全局变量
3:使用
__block修饰age
前两种方法我们就不细说了,在Block如何捕获外部变量一:基本数据类型中已经说的很明白了,并且前两种方法会一直保存在内存中占用内存.我们重点研究
__block关键字.
一:__block的本质
我们把使用__block修饰的age转换为C++代码,对比一下:
可以发现:使用
__block修饰的age底层被转换成了一个__Block_byref_age_0对象,我们重点研究一下这个对象.我们找到main函数中声明__block int age = 10这句代码的底层代码:
之前没有使用
__block修饰时,底层代码就是int age = 10,使用了__block修饰后,会发现变化如此之大,我们对这句转换后的代码简化一下:
ok,现在我们来梳理一下使用__block修饰的age变量和block的关系,为此,我截了一张 OC 代码和转换后的 C++ 代码的对比图,这样能更清晰的展示他们之间的关系:
这张图和清晰的展示了使用
__block修饰的age变量和block的关系,我们思考一下在block内部是如何修改age的值得,我们还是通过底层代码查看:
从截图中可以看到,
block内部修改auto变量,是先通过参数传递进来的block找到age结构体,然后通过age结构体找到__forwarding成员,通过之前的分析已经知道__forwarding存储的指针指向age结构体自己,所以本质上还是通过age结构体找到存储auto变量值得age成员,然后修改成 20.
思考一:为什么苹果要设计forwarding这种多此一举的方式呢?
因为当block从栈上拷贝到堆上后,__block变量也会拷贝到堆上.这时就有两份__block变量,一份栈上的,一份堆上的.如果__block修饰的变量是存放在栈上,这是forwarding指向的是它自己,这样没有问题.但是如果__block修饰的变量复制到堆上,它就会把栈上的forwarding指向堆上的变量,这样就能保证即使访问栈上的__block变量也能获取到堆上的变量值,如图:
思考二:如果我们修改的外部变量是对象类型,它的底层是怎样的呢?
通过对比我们发现,对象类型也会包装成一个结构体,并且这个结构体里面也会有一个成员存放
auto变量的值.区别是对象类型的结构体里面多了copy和dispose两个函数,我们在Block如何捕获外部变量二:对象类型里面已经讲过,因为对象类型会涉及到内存管理问题.
思考三:如图所示,我们在block内部给外部没有使用__block修饰的array类型的auto变量添加元素,会编译成功吗?
肯定会成功的,这里我们不要搞混淆了,我们给
array添加元素,是使用这个地址,而不是修改这个地址,如果我们array = nil这样才会报错.
思考四:通过上述分析,我们知道age结构体中会有一个成员存储auto变量的值,所以现在就有两个age.一个是age 结构体,另一个是存储变量值得age成员,那我们如果打印age的地址,会是哪个age的地址呢?
为了研究清楚这个问题,我们把底层的C++的
block结构体挪到我们的OC代码中,代码如下:
typedef void(^MYBlock)(void);
//impl结构体
struct __block_impl {
void *isa;
int Flags;
int Reserved;
void *FuncPtr;
};
//age结构体
struct __Block_byref_age_0 {
void *__isa;
struct __Block_byref_age_0 *__forwarding;
int __flags;
int __size;
int age;
};
//Desc结构体
struct __main_block_desc_0 {
size_t reserved;
size_t Block_size;
void (*copy)(void);
void (*dispose)(void);
};
//block结构体
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
struct __Block_byref_age_0 *age; // by ref
};
int main(int argc, const char * argv[]) {
@autoreleasepool {
//声明age
__block int age = 10;
//声明block
MYBlock block = ^{
age = 20;
NSLog(@"%p",&age);
};
struct __main_block_impl_0 *blockImpl = (__bridge struct __main_block_impl_0 *)block;
//调用block
block();
}
return 0;
}
这样我们就实现了把Block类型转换为struct __main_block_impl_0结构体,方便我们查看block结构体中成员变量的地址.
我们在函数返回之前设置一个断点,然后打印了一个地址
0x100405998,我们从变量视图中可以直接看到block结构体中的age结构体的地址是0x100405980,可以看出打印的地址和age结构体的地址并不相同.由此我们可以得出结论:打印的地址是age结构体中的age成员地址,并不是block内部捕获的age.
ok,我们来验证我们刚刚得出的结论.
- 验证方法一:
我们在变量视图中看到age结构体的地址是0x100405980,而我们知道,结构体的地址也是结构体第一个成员的地址,由此我们可以手动计算出结构体中age成员的地址:
//age结构体
struct __Block_byref_age_0 {//0x100405980 age结构体地址
void *__isa;// 占8字节 0x100405980 第一个成员的地址和age的地址相同
__Block_byref_age_0 *__forwarding;// 占8字节 isa的地址:0x100405980 + isa所占用的8字节 = 0x100405988
int __flags;// 占4字节 __forwarding 的地址:0x100405988 + __forwarding 所占用的8字节 = 0x100405990
int __size;// 占4字节 __flags地址:0x100405990 + __flags 所占用的4字节 = 0x100405994
int age; // 占4字节 __size 地址:0x100405994 + __size 所占用的4字节 = 0x100405998
};
可以看到,我们计算处理的地址0x100405998和打印出来的地址0x100405998是相同的,验证了我们刚才得出的结论.
- 验证方法二:通过命令行打印地址:
我们通过LLDB命令p/x &(blockImpl->age->age)打印出的age地址和NSLog输出的地址是相同的,再一次验证了我们刚才的结论.这张截图中的地址和上一张图中的地址不一样,是因为这张图是重新运行代码截取的,变量的内存地址已经改变了,大家不用纠结这里.
❓我们思考一下苹果为什么这样设计?因为苹果要隐藏它内部的实现,我们在修改__block修饰的age的值时,从表面看会以为真的是在直接修改age的值,如果不了解底层实现的话,根本就不知道被__block修饰的age已经被包装成了一个对象,而我们实际修改的是age结构体中的age成员的值.
二:__block的内存管理
我们在block如何捕获对象类型的文章中已经知道,如果block访问的是对象类型的变量,那么__main_block_desc_0结构体中会增加copy,dispose两个函数指针,这两个函数会根据变量的修饰符(__strong,__weak,__unretained)进行相应的操作,形成强引用(retain)或者弱引用或者是释放引用的变量.现在我们来研究一下,使用__block修饰的外部变量,在block内部是如何管理的.
声明一个__block修饰的age变量,并且在block内部访问它:
int main(int argc, const char * argv[]) {
@autoreleasepool {
//声明 age 变量
__block int age = 10;
//声明block
MYBlock myblock = ^{
NSLog(@"%d",age);
};
//调用block
myblock();
}
return 0;
}
然后我们转成 C++ 代码,看看block底层是如何管理的:
//desc结构体
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};
会发现同访问了对象类型的变量一样,__main_block_desc_0结构体中同样有copy,dispose函数,可能有人会有疑问,因为在block如何捕获对象类型中我们说过,只有在访问对象类型的auto变量时才会生成copy dispose.为什么访问 __block int 时也会产生呢?
在上面我们说过,block在访问__block修饰的变量时,其底层会被封装成__Block_byref_age_0类型,在这个类型存在一个void *__isa成员,所以本质上它就是一个对象类型.
Block内部是如何管理使用__block修饰的变量的呢?
- 在栈上的block,不会对__block产生强引用
- 当block拷贝到堆上时
1:会调用block内部的copy函数
2:copy函数内部会调用__main_block_copy_0函数
3:__main_block_copy_0会调用_Block_object_assign函数对__block变量形成强引用(return)
也就是说,一旦_Block_object_assign调用,就会对block内部的__block变量产生强引用
如图:
思考一下:__block int age = 10是存放在栈上的,而MYBlock myblock是存放在堆上的,我们使用堆上的地址去指向栈空间肯定是不行的,那block的内部是如何处理这种情况的呢?
结论就是,当栈上的blcok拷贝到堆上时,会把__block修饰的变量一同拷贝到堆上,如图:
而当block从堆中移除时:
1:调用block内部的dispose函数
2:dispose函数会调用
_Block_object_dispose函数
3:
_Block_object_dipose函数会自动释放引用的__block变量(release)
如图:
思考一下,苹果为什么会这么设计呢?其实这个也很好理解,因为使用__blcok修饰的变量,底层其实被封装成了对象,而我们要在block中使用这个对象,就肯定要对这个对象的引用负责.
既然 block 访问对象类型的变量和访问使用 __block 修饰的变量都会增加copy,dispose函数,那么他们之间有没有区别呢?
他们之间的区别就是:
- 如果使用__block修饰的变量,block内部直接对其强引用
- 如果是对象类型的变量,会根据变量的修饰符
__weak , __strong来决定是否强引用
三:block访问 __block 修饰的对象类型
到目前为止,我们讲解了block访问 基本数据类型 (int age) , __block 修饰的基本数据类型 (__block int age), 对象类型 NSObject *object三种情况,下面我们分析一下第四种情况: __blcok 修饰的对象类型.
int main(int argc, const char * argv[]) {
@autoreleasepool {
Person *person = [[Person alloc]init];
__block Person *blockPerson = person;
MYBlock block = ^{
NSLog(@"%@",blockPerson);
};
block();
}
return 0;
}
我们创建一个Person类,然后使用__block修饰一个person对象,在block 中访问,查看底层代码如下:
// __block 底层对象
struct __Block_byref_blockPerson_0 {
void *__isa;
__Block_byref_blockPerson_0 *__forwarding;
int __flags;
int __size;
void (*__Block_byref_id_object_copy)(void*, void*);
void (*__Block_byref_id_object_dispose)(void*);
// __block 中强引用 Person 对象
Person *__strong blockPerson;
};
// block 底层对象
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
// block中强引用 __Block_byref_blockPerson_0
__Block_byref_blockPerson_0 *blockPerson; // by ref
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_blockPerson_0 *_blockPerson, int flags=0) : blockPerson(_blockPerson->__forwarding) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
// block 代码块
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
__Block_byref_blockPerson_0 *blockPerson = __cself->blockPerson; // bound by ref
NSLog((NSString *)&__NSConstantStringImpl__var_folders_5t_pxd6sp5x6rl9gnk21q2q934h0000gn_T_main_ea4426_mi_0,(blockPerson->__forwarding->blockPerson));
}
可以看到使用__block修饰的对象底层被封装成了__Block_byref_blockPerson_0类型的对象,__Block_byref_blockPerson_0这个对象类型的结构体中有一个Person *__strong blockPerson成员,强引用着我们在main函数中创建的Person对象,而__main_block_impl_0中的blockPerson又强引用着__Block_byref_blockPerson_0对象,他们的关系如下图:
我们稍作修改,在
blockPerson添加__weak关键字:
int main(int argc, const char * argv[]) {
@autoreleasepool {
Person *person = [[Person alloc]init];
__block __weak Person *blockPerson = person;
MYBlock block = ^{
NSLog(@"%@",blockPerson);
};
block();
}
return 0;
}
查看底层代码:
// __block 底层对象
struct __Block_byref_blockPerson_0 {
void *__isa;
__Block_byref_blockPerson_0 *__forwarding;
int __flags;
int __size;
void (*__Block_byref_id_object_copy)(void*, void*);
void (*__Block_byref_id_object_dispose)(void*);
//这里变成了弱引用,说明这里的引用情况取决于外部变量的修饰符
Person *__weak blockPerson;
};
// block 底层对象
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
//这里还是强引用,说明 __weak 关键字并不会影响这里
__Block_byref_blockPerson_0 *blockPerson; // by ref
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_blockPerson_0 *_blockPerson, int flags=0) : blockPerson(_blockPerson->__forwarding) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
// main 函数
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
__Block_byref_blockPerson_0 *blockPerson = __cself->blockPerson; // bound by ref
NSLog((NSString *)&__NSConstantStringImpl__var_folders_5t_pxd6sp5x6rl9gnk21q2q934h0000gn_T_main_4ce55f_mi_0,(blockPerson->__forwarding->blockPerson));
}
查看底层代码我们发现,block内部对于__Block_byref_blockPerson_0的引用没有变化,但是__Block_byref_blockPerson_0中的blockPerson已经从强引用变成了弱引用.如图:
现在我们来验证一下
__Block_byref_blockPerson_0中的blockPerson对Person对象的强引用和弱引用两种情况:
我们添加
__weak后再看看:
通过对比我们就验证了
__Block_byref_blockPerson_0中的blockPerson对Person对象的引用存在强引用和弱引用两种情况,这两种情况取决于Person对象的修饰符.
这里需要注意一点,
__Block_byref_blockPerson_0中的blockPerson对Person对象的强引用只有在ARC环境下才会retain,在MRC环境下只会弱引用.如图:
我们演示一下,我们把环境切换为 MRC ,然后把 block copy 到堆上:
❓大家思考一下,如果把
__block去掉,会怎么样?
如果把
__block去掉,blcok 就会对 person 产生强引用,在 block 释放之前,person 是不会释放的,因为去掉__block后,就没有__Block_byref_blockPerson_0这个中间层,blcok 会直接强引用 person对象,如图: