OC与Swift闭包通过weak和strong联合使用的理解

撰写于 2016-08-29 修改于 2016-08-29

前言

本文不会详细介绍Block(闭包)使用，网上也有很多详细的介绍。我们使用Block经常要注意循环引用问题，在很早以前我只用到了__weak并不知道__strong用的有啥意义存在。后来遇到坑了才明白其中的真理！之前文章中也提到这个问题，仅仅是讲了使用层面，并没有去讲如何理解其中的道理，接下来我们来理解一下。

目录

1.OC中Block的循环引用

我创建一个LRShop类，其中有下面2个属性：

1
2
@property (nonatomic, copy)NSString *string;
@property (nonatomic, copy)void(^myBlock)();

首先我们从基础一步一步去理解，先分析下面的代码：

1
2
3
4
5
6
LRShop *shop = [[LRShop alloc]init];
    shop.string = @"welcome to our company";
    shop.myBlock = ^{
        NSLog(@"%@",shop.string);
    };
    shop.myBlock();

如果block代码块的内部，使用了外面的强引用shop对象（也就是shop.myBlock代码块内部使用了NSLog(@"%@",shop.string);），block代码块的内部会自动产生一个强引用，引用着shop对象！所以上面的shop不会被销毁，造成循环引用！下面画一张图方便去理解：

图中的每条橙色的线都是强引用。shop指向着LRShop对象，内部myBlock指向着Block代码块，string指向着@"",最后Block代码块指向着LRShop对象。

__weak的使用

解决循环引用的问题我们第一个会用到__weak我这里声明了一个宏，
如果不明白这个宏可以看这篇文章中的第8点：

1
2
3
4
5
6
7
#define LRWeakSelf(type)  __weak typeof(type) weak##type = type;
 LRWeakSelf(shop);
    shop.myBlock = ^{
        NSLog(@"%@",weakshop.string);
    };
    shop.myBlock();

Block外部声明了一个弱引用，在内部使用就不会造成循环引用，所以如果block代码块的内部，使用了外面声明的的弱引用weakshop对象（也就是shop.myBlock代码块内部使用了NSLog(@"%@",weakshop.string);），block代码块的内部会自动产生一个弱引用，引用着shop对象！我们继续来看下内存图：

总结：Block内部使用外部的一个对象，如果外部对象是强引用那么内部会自动生成一个强引用，引用着外部对象。如果外部对象是弱引用那么内部会自动生成一个弱引用，引用着外部对象。如果还是有点迷茫我们最后在举一个例子：

1
2
3
4
5
6
self.myName = @"我的名字是杰克!";
LRShop *shop = [[LRShop alloc]init];
       shop.myBlock = ^{
            NSLog(@"%@",self.myName);
};
shop.myBlock();

上面的代码会不会造成循环引用呢？答案是不会的，首先self.myName是ViewController控制器的一个属性，Block内部使用外部的self.myName，外部的self.myName是强引用那么内部会自动生成一个强引用引用着self.myName。Block内部强引用self.myName，但是self.myName没有强引用Block！说白了就是粉丝与明星的关系，粉丝(Block)单方面追求明星(self.myName)，但是随便粉丝怎么单方面的追求，明星都不搭理粉丝！

__weak 与 __strong 一起使用

我们先看看下面代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//2个宏
#define LRWeakSelf(type)  __weak typeof(type) weak##type = type;
#define LRStrongSelf(type)  __strong typeof(type) type = weak##type;
------------------------------------------------------
 	LRShop *shop = [[LRShop alloc]init];
    shop.string = @"welcome to our company";
    
    LRWeakSelf(shop);
    shop.myBlock = ^{
        LRStrongSelf(shop)
        NSLog(@"%@",shop.string);
    };
    shop.myBlock();

表面来看外部一个弱引用，内部一个强引用那不是跟没写一样么？我们要理解一个问题LRStrongSelf(shop)是Block内部的强引用，而不是外部强引用。所以Block内部声明的强引用不管怎么访问都是不会干扰外部的对象，也不会自动产生一个强引用。所以没有循环引用，也能输出shop.string看着跟之前讲的仅仅使用__weak没什么区别，那我们在来看看下面的代码：

仅仅使用LRWeakSelf(shop);并且在myBlock中增加一个延迟2秒在输出就会出现问题, 虽然对象销毁了, 输出的值却是null

1
2
3
4
5
6
7
8
//弱引用
 LRWeakSelf(shop);
    shop.myBlock = ^{
        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
            NSLog(@"%@",weakshop.string);
        });
    };
    shop.myBlock();

如果LRWeakSelf(shop);与LRStrongSelf(shop);一起使用输出的shop.string有值,对象也销毁了：

1
2
3
4
5
6
7
8
LRWeakSelf(shop);
    shop.myBlock = ^{
        LRStrongSelf(shop)
        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
            NSLog(@"%@",shop.string);
        });
    };
    shop.myBlock();

那这又是什么原因呢？我们继续画个内存图来看看：

额~ 这图有点乱啊，那就来一步一步分析，分析完之后上面所有的问题就会迎面而解！

  • 1.LRShop *shop = [[LRShop alloc]init];这行代码一执行就会出现图中第1条强引用的线，引用着LRShop对象。
  • 2.LRWeakSelf(shop);这行代码一执行就会出现图中第2条弱引用的线，引用着LRShop对象，第3条线我们可以跳过不用看。
  • 3.shop.myBlock = ^{}这行Block代码一执行就会出现图中第4条强引用的线。
  • 4.之后会执行shop.myBlock();这行代码，回调到Block代码块中，然后会执行LRStrongSelf(shop)这行代码，在执行这行代码前会自动产生第5条弱引用的线引用着LRShop对象(原因：Block内部使用外部的一个对象，如果外部对象是弱引用那么内部会自动生成一个弱引用，引用着外部对象)，最后就产生第6条强引用的线，引用着LRShop对象。
  • 5.dispatch_after这行代码一执行就会出现图中第7条GCD系统内部强引用的线，引用着dispatch_after。
  • 6.由于GCD的dispatch_after代码块内部用到NSLog(@"%@",shop.string);用到了外部的强引用对象shop(原因：Block内部使用外部的一个对象，如果外部对象是强引用那么内部会自动生成一个强引用，引用着外部对象。)所以就会出现图中第8条强引用的线，引用着LRShop对象。

上面6条是如何创建的，下面是如何释放的：

  • 1.dispatch_after的Block内部会延迟2秒执行，并且不会阻塞线程，所以任务会一直往下走，当shop.myBlock = ^{}的Block大括号执行完，内部的局部变量LRStrongSelf(shop)就会销毁，第6条线就会销毁。
  • 2.最终- (void)viewDidLoad {}的大括号也会执行完，所以LRShop *shop = [[LRShop alloc]init];与 LRWeakSelf(shop);局部变量也会销毁，第1条线与第2条线都会销毁。
  • 3.现在只剩下GCD的第8条线强引用着LRShop对象，所以LRShop对象没有销毁，只有等待的2秒结束后，因为LRShop对象没有死所以输出有值，然后GCD系统内部不会再去强引用dispatch_after的Block，首先第7条线销毁，第8条线在销毁。最后没有人强引用LRShop对象所以全部销毁！

2.Swift 闭包

在Swift中解决闭包循环引用有三种办法我们来看看：

  • 1.weak var weakShop = shop方式解决循环引用，在平时开发中我们不用这个方法，用起来很麻烦！
1
2
3
4
5
6
7
let shop : LRShop = LRShop()
weak var weakShop = shop
shop.myBlock = {(str : String) -> () in
    weakShop?.string = str
    print((weakShop?.string)!)
}
shop.myBlock!(str: "哈喽，你好！")
  • 2.[unowned shop]方式解决循环引用，在平时开发中我们不用这个方法，这个方法是很危险的！
1
2
3
4
5
6
let shop : LRShop = LRShop()    
   shop.myBlock = {[unowned shop] (str : String) -> () in
        shop.string = str
        print(shop.string!)
    }
    shop.myBlock!(str: "哈喽，你好！")
  • 3.[weak self]方式解决循环引用，在平时开发中我们经常用这个方法，这个方式只是一种简便的写法！
1
2
3
4
5
6
let shop : LRShop = LRShop()
shop.myBlock = {[weak shop] (str : String) -> () in
        shop?.string = str
        print((shop?.string)!)
}
shop.myBlock!(str: "哈喽，你好！")

输出结果都能解决循环引用问题，下图deinit相当OC中的dealloc方法:

那我们已经知道Swift中用weak也能解决循环引用，那么可不可以weak与strong一起使用呢？我找了没有strong这个关键字，那我们该如何解决下面延迟2秒后在执行任务的问题呢：

1
2
3
4
5
6
7
8
9
10
11
12
13
let shop : LRShop = LRShop()
        
    shop.myBlock = {[weak shop] (str : String) -> () in
            //时间设置
            let time: NSTimeInterval = 2.0
            //GCD：延迟2秒
            dispatch_after(dispatch_time(DISPATCH_TIME_NOW,
                    Int64(time * Double(NSEC_PER_SEC))), dispatch_get_main_queue()) {
                        shop?.string = str
                        print((shop?.string))
            }
        }
        shop.myBlock!(str: "哈喽，你好！")

我觉得既然没有strong那肯定会有其他办法来解决这个问题，既然只缺少一个强引用，那我就声明一个强引用给他用：

1
let strongShop = shop;

上面代码就是我在闭包内部声明的一个strongShop强引用，详细代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
let shop : LRShop = LRShop()
   
   shop.myBlock = {[weak shop] (str : String) -> () in
   	  //强引用
       let strongShop = shop;
       
       //时间设置
       let time: NSTimeInterval = 2
       //GCD：延迟2秒
       dispatch_after(dispatch_time(DISPATCH_TIME_NOW,
           Int64(time * Double(NSEC_PER_SEC))), dispatch_get_main_queue()) {
               //赋值
               strongShop?.string = str
               //打印输出
               print((strongShop?.string)!)
       }
   }
   shop.myBlock!(str: "哈喽，你好！")

不管在OC中还是Swift中我们都解决了Block(闭包)中如何优雅的解决循环引用问题，并且也了解了造成循环引用的内存表现形式。上面在Swift解决循环引用的问题，有更好的办法还请大神多多指教，如果有错误的地方帮忙纠正，非常感谢！

目录

  1. 前言
  2. 目录
  3. 1.OC中Block的循环引用
    1. __weak的使用
    2. __weak 与 __strong 一起使用
  • 2.Swift 闭包
    • Site by Lu Ran using Hexo & Random

    Hello! 我是卢然, 现居北京的一个iOS开发者, 非人类般的修炼中~

    Hide