iOS随笔——初识Block和Closure的循环引用

OC中的block和swift中的闭包使得我们能够优雅的解决很多问题,但是其内存释放问题也让像我这样的初学者感到头疼

1.如何查看程序中的循环引用

这里简单的提及两个我个人比较常用的方法(欢迎大家补充)

  • oc的dealloc中和swift的deinit中打印日志,通过控制器的释放情况判断当前控制器中是否存在循环引用
  • Leaks,Xcode自带的检测循环引用的工具,简洁实用
2.OC中的Block解析
  • 简单的循环引用的例子
UIButton *smartButton = [UIButton buttonWithType:UIButtonTypeCustom];
smartButton.frame = CGRectMake(50, 150, 50, 50);
 [smartButton setBackgroundColor:[UIColor redColor]];
 [self.view addSubview:smartButton];
 [smartButton buttonWithBlock:^(UIButton *button) {
     [self.navigationController popViewControllerAnimated:YES];
 }];
 - (void)dealloc {
    NSLog(@"%s",__func__);
}

当我执行按钮方法返回上层页面时,dealloc没有被执行
我们可以看一下这里的内存循环状况
vc->smartButton->block->vc
当控制器持有block后,block内又捕获了控制,造成循环引用
那么我们可以从block->vc这里入手,使得block不再强引用控制器,打破这个循环

__weak typeof(self) weakSelf = self;
    [smartButton buttonWithBlock:^(UIButton *button) {
        [weakSelf.navigationController popViewControllerAnimated:YES];
    }];

这样dealloc被调用看到如下打印-[TestViewController dealloc]
关于block捕获vc的一点拓展:
在ARC环境下,对于在堆上_NSConcreteMallocBlock类型的block(即对栈上的block进行copy操作后,被复制到堆上),会有以下特性:
(1) block内部如果通过外面声明的强引用来使用,那么block内部会自动产生一个强引用指向所使用的对象。
(2) block内部如果通过外面声明的弱引用来使用,那么block内部会自动产生一个弱引用指向所使用的对象。
这也是smartButtton会捕获vc,浅层的理解


  • 滥用__weak的情况
    很多包括我在内的初学者,存在滥用_weak的问题,遇到Block先weak一下,这是个非常不好习惯,相信你看到这么一份别人的代码也会很头疼
SmartTool *smartTool = [[SmartTool alloc] init];
 [smartTool stupidBlock:^{
     [self.navigationController popViewControllerAnimated:YES];
 }];
[UIView animateWithDuration:1.0 animations:^{
     self.view.backgroundColor = [UIColor orangeColor];
 }];
NSArray *smartArr = @[@"1"];
 [smartArr enumerateObjectsUsingBlock:^(id  _Nonnull obj, NSUInteger idx, BOOL * _Nonnull stop) {
     if ([obj isEqualToString:@"1"]) {
         self.view.backgroundColor = [UIColor orangeColor];
         *stop = YES;
     }
 }];

诸如此类很多代码就算block中捕获了控制也不会造成循环引用,因为blcok并不被vc强引用,更多的思考可以让你的代码更加优雅


  • strongSelf的使用
__weak typeof(self) weakSelf = self;
 [smartButton buttonWithBlock:^(UIButton *button) {
     __strong typeof(weakSelf) strongSelf = weakSelf;
     [strongSelf doSomething];
     [strongSelf doAnotherThing];
     // ... 可能在一个block会有很多逻辑
     [strongSelf.navigationController popViewControllerAnimated:YES];
 }];

这是一个比较官方的说法,如果你不用strongSelf的话,执行方法的过程中可能weakSelf被析构,从而导致weakSelf = nil,导致方法不被调用,甚至crash

我们先来看一个问题,可能会困扰初学者,_strongSelf为什么不会造成循环引用,block不是也强引用的vc嘛?这和我们第一个造成循环引用的例子有何不同?

这里只要区别在于
1.直接强引用,会引用block整个生命周期,造成循环引用
2.在block内强引用,_strongSelf会在Block内执行完后被释放,也就是其生命周期在block执行时


接着我们来看一下析构的例子:

SmartTool *tool = [[SmartTool alloc] init];
 __weak SmartTool *weakTool = tool;
 tool.luckBlock = ^{
     dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
         [weakTool stupidLog];
     });
 };
 tool.luckBlock();

这里在block里面做一个简单GCD的延时打印方法
执行代码发现[weakTool stupidLog]方法并没有被调用,打印发现在GCD的block中weakTool已经被析构,为nil
由于tool为局部变量,当执行完外部代码,tool被释放,luckBlock弱引用tool,weakTool当执行完luckBlock内部逻辑后被释放,当延迟2s后再调用weakTool时,weakTool已经为nil

此处需要强引用weakTool,就能正常执行打印方法

tool.luckBlock = ^{
   __strong SmartTool *strongTool = weakTool;
   dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
         [strongTool stupidLog];
   });
};

对于此处的两个block:
1.luckBlock,strongTool对于其是内部变量,其生命周期只在luckBlock执行时
2.GCDBlock,strongTool对于其是外部变量,GCDBlock会强引用strongTool,直到2s后[strongTool stupidLog]方法被调用后GCDBlock被销毁,strongTool也被销毁

有兴趣的同学,可以看一下这段代码

@property (nonatomic,copy)void(^block)();

__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 test];
    });
};
self.block();

  • 主动创建循环引用的场景
    比如以下需求,当你执行完一个后台任务之后,通知某个实例对象,做相关操作,这时候你必须保证相方都存在,并在做完相关操作之后主动断开引用
    主动断开循环引用的例子:
AFN中,传入Block是被AFURLSessionManagerTaskDelegate对象引用
而AFURLSessionManagerTaskDelegate被mutableTaskDelegatesKeyedByTaskIdentifier字典引用
AFN在block执行完后,mutableTaskDelegatesKeyedByTaskIdentifier字典会移除AFURLSessionManagerTaskDelegate对象
这样block也被释放

避免的循环引用的总结:
1.事先通过weak-strong dance 处理引用关系
2.事后在合适位置主动断开


swift中闭包解析

闭包与Block循环引用的原理是相同的,只是语法上存在一些区别

  • weak
let smartButton = UIButton(type: .Custom);
smartButton.buttonClickWithClosure { [weak self] (button) in
      self?.doSomething
}
 self.view.addSubview(smartButton);
  • unowned
    weak 和 unowned的语法是一致的,区别在于
    weak:属性是可选的,对象销毁时置nil
    unowned:属性是不可选的,必须在初始化方法中初始化值,类似oc中的unsafe_unretained
  • strong
let smartButton = UIButton(type: .Custom);
smartButton.buttonClickWithClosure { [weak self] (button) in
      guard let strongSelf = self else { return }
      strongSelf.doSomething
      strongSelf.doAnotherthing
}
self.view.addSubview(smartButton);

如有错误,希望大家即时指正
转载请注明出处,谢谢

你可能感兴趣的:(iOS随笔——初识Block和Closure的循环引用)