block底层原理探究(二)：内存管理
前篇block底层原理探究(一)：捕获，我们探究了block捕获外部变量的原理；
如果block捕获的是对象类型的auto变量，就要涉及到对象的内存管理问题了（对于捕获的基本数据类型，不用进行内存管理）；本篇，我们就来探究block对捕获的对象类型的变量是如何进行内存管理的；
对象类型的auto变量
和之前一样通过命令xcrun -sdk iphoneos clang -rewrite-objc -fobjc-arc -fobjc-runtime=ios-9.0.0 main.m（ARC环境）将以下代码重写为C++代码进行分析：
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSObject *obj = [[NSObject alloc] init];
void (^block)(void) = ^{
NSLog(@"%@",obj);
};
block();
}
return 0;
}
对应C++代码：
- main函数
int main(int argc, const char * argv[]) {
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
NSObject *obj = ((NSObject *(*)(id, SEL))(void *)objc_msgSend)((id)((NSObject *(*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("NSObject"), sel_registerName("alloc")), sel_registerName("init"));
void (*block)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, obj, 570425344));
((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
}
return 0;
}
- block结构及函数调用
对比之前捕获基本数据类型（int i）的代码，很容易发现两者的不同：
- 被捕获的NSObject类型的变量obj前面有
__strong修饰，表示这是一个强引用；这个是根据外部变量引用类型决定的，以上obj的声明默认就是强引用：
__strong NSObject *obj = [[NSObject alloc] init];
因此捕获的变量也是__strong，如果外部变量改为weak弱引用，则捕获变量则为__weak；
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSObject *obj = [[NSObject alloc] init];
__weak NSObject *weakObj = obj;
void (^block)(void) = ^{
NSLog(@"%@",weakObj);
};
block();
}
return 0;
}
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
NSObject *__weak weakObj;
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, NSObject *__weak _weakObj, int flags=0) : weakObj(_weakObj) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
-
__main_block_desc_0结构多了两个函数指针：copy，dispose;
- 当block被copy到堆上时，就会调用copy函数；copy函数实现如下：
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {
_Block_object_assign((void*)&dst->obj, (void*)src->obj, 3/*BLOCK_FIELD_IS_OBJECT*/);
}
_Block_object_assign这个函数会根据内部捕获的变量obj的修饰符（__strong、__weak、__unsafe_unretained），做出相应操作，形成强引用（retain,引用计数+1）或者弱引用；
如果block类型为__NSStackBlock__（栈block），不会调用copy函数，因此不管捕获的变量是__strong还是__weak，都不会产生强引用；因为栈block处于栈区，block本身都是交由系统管理内存的，也就没必要对捕获的对象强引用；
- 如果block从堆上移除，则会调用dispose函数，dispose函数内部会调用
_Block_object_dispose函数，_Block_object_dispose函数会自动释放引用的auto变量obj对象（release,引用计数-1）；
接下来，简单写个demo验证以上过程：
@implementation Dog
- (void)dealloc {
NSLog(@"%s",__func__);
}
@end
int main(int argc, const char * argv[]) {
void (^block)(void);
{
Dog *dog = [[Dog alloc] init];
block = ^{
NSLog(@"%@",dog);
}; // ARC环境 block会自动copy到堆上
block();
}
NSLog(@"---------");
return 0;
}
输出结果：
<Dog: 0x100606f50>
---------
-[Dog dealloc]
我们知道，ARC环境下，dog对象出了其对应的作用域后就会释放；那么正常情况下，输出结果-[Dog dealloc]应该在分割线---------前；但现在明显的是dog对象出了作用域仍然存活着，这就是因为block被copy到堆上时调用了内部的_Block_object_assign函数对捕获的对象强引用了，因此dog对象出了作用域后release，但引用计数为1不会销毁；当main函数结束后，block也就销毁，这时会调用内部的_Block_object_dispose函数对dog对象release；
同样的代码，现在改为MRC环境，由于MRC栈block不会自动copy到堆上，因此不存在强引用，结果和__weak变量一样的结果；
int main(int argc, const char * argv[]) {
void (^block)(void);
{
Dog *dog = [[Dog alloc] init];
__weak Dog *weakDog = dog;
block = ^{
NSLog(@"%@",weakDog);
};
block();
}
NSLog(@"---------");
return 0;
}
<Dog: 0x10064dbc0>
-[Dog dealloc]
---------
__block修饰的基本数据类型变量
__block修饰的变量，实际上会将原本变量包装成一个对象；因此block对于__block变量也需要进行内存管理；
int main(int argc, const char * argv[]) {
@autoreleasepool {
__block int i = 0;
void (^block)(void) = ^{
NSLog(@"%d",i);
};
block();
}
return 0;
}
以上代码重写为C++代码，可以发现和对象类型的auto变量的代码差不多，都会有copy,** dispose**；只不过管理的对象是__block包装后的对象：
// __block对象
struct __Block_byref_i_0 {
void *__isa;
__Block_byref_i_0 *__forwarding;
int __flags;
int __size;
int I;
};
block对于__block变量的内存管理和对象类型的auto变量大致一样，其处理过程如下：
- block在栈上时，不产生强引用
- 当block被copy到堆上时，__block对象也会被copy到堆上，block调用copy函数，内部的_Block_object_assign函数对__block变量强引用；（堆上的block对堆上的__block对象强引用）
- block从堆中移除时，调用dispose函数，内部的_Block_object_dispose会释放变量
不同于对象类型的auto变量，捕获__block变量时，_Block_object_assign函数不会判断内部变量是__strong还是__weak，一律都强引用，因为__block包装的对象本身就只是强引用；
__block修饰的对象类型变量
int main(int argc, const char * argv[]) {
@autoreleasepool {
__block NSObject *obj = [[NSObject alloc] init];
void (^block)(void) = ^{
NSLog(@"%@",obj);
};
block();
}
return 0;
}
转换后的代码和__block基本数据类型差不多，只不过__block包装的对象结构不同：
可以看到，结构中多了copy,dispose函数；原本的obj对象也根据外部引用类型为__strong强引用；copy,dispose函数底层实现和block的__main_block_copy_0``__main_block_dispose_0是一样的；也就是说block管理__block对象内存，__block对象以同样的方式管理obj对象内存：block被copy到堆上，会调用block的copy函数__main_block_copy_0，对__block对象强引用；然后__block对象调用自己的copy函数__Block_byref_id_object_copy，内部的_Block_object_assign函数根据原始的obj对象的引用类型（__strong、__weak），形成强引用或弱引用；
外部变量，可以在__block的基础上加上__weak实现弱引用：
NSObject *obj = [[NSObject alloc] init];
__weak __block NSObject *weakObj = obj;
void (^block)(void) = ^{
NSLog(@"%@",weakObj);
};
block();
相比前面两种情况，对于__block修饰的对象类型变量的内存管理只是多了一层引用关系：
循环引用
block会对捕获的对象强引用，因此使用block时容易出现循环引用问题；解决循环引用的方法之一就是使用__weak或__unsafe_unretained定义变量，打破循环引用：
另一种解决方案是使用__block，然后在block实现里将捕获的对象置nil；
int main(int argc, const char * argv[]) {
@autoreleasepool {
__block Dog *dog = [[Dog alloc] init];
dog.block = ^{
NSLog(@"%@",dog);
dog = nil;
};
dog.block();
}
return 0;
}
但是这种方案要求必须调用block，而且将对象置为nil后，如果其他地方还需要使用该对象也会有问题；
Strong-Weak Dance
我们可以使用__weak修饰符避免循环引用，但是有个注意点，苹果把它称为：Strong-Weak Dance;
首先来看下使用__weak可能出现的问题，简单写了个例子：
点击一个控制器的界面跳转进另外一个控制器界面,在这个控制器中,给自己的block赋值；block里延迟2s执行dosomething操作；当点击这个界面时返回上个控制器，如果没有其他对象强引用这个控制器，则这个OtherViewController会正常释放；
@interface OtherViewController ()
@property (nonatomic, copy) void (^block)(void);
@end
@implementation OtherViewController
- (void)viewDidLoad {
[super viewDidLoad];
__weak typeof(self) weakSelf = self;
self.block = ^{
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
[weakSelf dosomething];
});
};
self.block();
}
- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
[self dismissViewControllerAnimated:YES completion:nil];
}
- (void)dosomething {
NSLog(@"%s",__func__);
}
- (void)dealloc {
NSLog(@"%s",__func__);
}
@end
当跳转到OtherViewController后，我们2s后点击屏幕，根据打印结果可以知道vc正常释放没有循环引用，并且block内部代码正常调用：
-[OtherViewController dosomething]
-[OtherViewController dealloc]
当我们在2s内点击屏幕时，vc正常释放但block内的dosomething并未调用：
-[OtherViewController dealloc]
这就是因为，dismissViewControllerAnimated后，vc会release引用计数减为0对象释放了，由于block内部是__weak引用，对象释放后weak指针会自动置为nil，OC中对nil发送消息就是什么也不做；block内的代码不会调用只是相对轻微的影响，但是当对nil做某些操作时（比如数组中插入nil）就会crash，这个影响就比较严重；
- (void)viewDidLoad {
[super viewDidLoad];
__weak typeof(self) weakSelf = self;
self.block = ^{
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
NSArray *arr = [NSArray arrayWithObject:weakSelf]; // 有crash风险
});
};
self.block();
}
像这种，在调用block内代码时block捕获的对象已提前释放的情况，有很大几率会出现的；尤其是多线程的情况下，更容易出现这种问题；
解决方案就是，在block实现中再将weak对象转为strong对象，后续使用这个strong对象就没问题了；
这种由强引用 --> 弱引用 --> 强引用的变换过程，就是Strong-Weak Dance；
对应代码如下：
- (void)viewDidLoad {
[super viewDidLoad];
__weak typeof(self) weakSelf = self;
self.block = ^{
__strong typeof(self) strongSelf = weakSelf;
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
[strongSelf dosomething];
});
};
self.block();
}
这样，不管什么时候点击屏幕，OtherViewController都是要等到block执行完后才销毁；
Strong-Weak Dance这样既解决了循环引用的问题，又避免了对象提前释放引起的问题；
（如无特别说明，以上内容都是针对ARC而言）
