iOS开发笔记之五十七——__weak与__strong是如何解决循环引用的

当我们写一个block时，如果你的block涉及被self持有以及需要访问self的成员时，循环引用问题由此产生。解决的办法也很简单，其中利用__weak与__strong是常见的手段，类似代码如下：

__weak typeof(self) weakSelf = self;
self.block = ^{
      __strong typeof(weakSelf) strongSelf = weakSelf;
      [strongSelf print];
};

如果要把这个问题说清楚明白，不是件容易的事，看了很多文章，都没有深入全面地讲明白这个问题。为了深入剖析其中的原理，构建了一个MyTestBlock类，类的结构代码如下：

//
//  MyTestBlock.h
//  myBlock
//
//  Created by lizitao on 16/10/2.
//  Copyright © 2016年 lizitao. All rights reserved.
//

#import <Foundation/Foundation.h>

@interface MyTestBlock : NSObject

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

@end

//
//  MyTestBlock.m
//  myBlock
//
//  Created by lizitao on 16/10/2.
//  Copyright © 2016年 lizitao. All rights reserved.
//

#import "MyTestBlock.h"

@implementation MyTestBlock

- (void)dealloc
{
    NSLog(@"------>dealloc");
}

- (instancetype)init
{
    self = [super init];
    if (self)
    {
        __weak typeof(self) weakSelf = self;
        self.block = ^{
            __strong typeof(weakSelf) strongSelf = weakSelf;
            [strongSelf print];
        };
    }
    return self;

}

- (void)print
{
    NSLog(@"---->print");
}

@end

然后在main方法里测试它：

//
//  main.m
//  myBlock
//
//  Created by lizitao on 16/10/2.
//  Copyright © 2016年 lizitao. All rights reserved.
//

#import <Foundation/Foundation.h>
#import <objc/runtime.h>
#import "MyTestBlock.h"

int main(int argc, const char * argv[])
{
    @autoreleasepool
    {
        MyTestBlock *testBlock = [[MyTestBlock alloc] init];
        testBlock.block();
    }
    while (1) {;} //让主程序一直运行不退出
    return 0;
}

代码中，block属性为copy，定义为copy属性是一个存放在堆的block，堆block从栈复制过程中会复制它所使用的变量的引用（非__block属性），循环引用也是因此产生。画了个简单的示意图，如下：

对于代码中的这一步，是如何打破这个循环的呢？我们在block外的weakSelf构造了一个指向self的弱引用，如下：

__weak typeof(self) weakSelf = self;

如下图所示：

如果你的block之行不是异步之行，在显示调用testBlock.block()时，就已经执行，此时的strongSelf变量是可以省略的，如下：

__weak typeof(self) weakSelf = self;
self.block = ^{
       [weakSelf print];
};

打印结果如下：

2017-02-03 12:13:35.881 myBlock[6131:4562526] ---->print
2017-02-03 12:13:35.883 myBlock[6131:4562526] ------>dealloc

虽然循环引用就打破了，但是新的问题又来了。那就是会有self提前于block执行之前释放的场景，testBlock实体释放了，self就指向nil了，weakSelf也会被置为nil，等block回来时，其实在向一个nil发消息。此时就用到了strongSelf，它的作用主要是应对异步执行的block，添加异步逻辑如下：

__weak typeof(self) weakSelf = self;
self.block = ^{
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        [NSThread sleepForTimeInterval:5];
        [weakSelf print];
    });
};

此时的执行结果如下：

2017-02-03 12:19:14.229 myBlock[6181:4566726] ------>dealloc

block中的语句没有执行，添加strongSelf逻辑之后：

__weak typeof(self) weakSelf = self;
self.block = ^{
    __strong typeof(weakSelf) strongSelf = weakSelf;
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
       [NSThread sleepForTimeInterval:5];
        [strongSelf print];
                
   });
};

5s之后的打印结果如下：

2017-02-03 13:30:23.129 myBlock[6327:4593186] ---->print
2017-02-03 13:30:23.131 myBlock[6327:4593186] ------>dealloc

针对上面的过程，补充流程图如下：

有人看到这里，肯定会有疑惑，这里strongSelf的引用不又像前面的self一样导致了循环引用了吗？这里需要好好解释一下：

self是一个指向实例对象的指针，它的生命周期至少是伴随着当前的实例对象的，所以一旦它和对象之间有循环引用是无法被自动打破的；strongSelf是block内部的一个局部变量，变量的作用域仅限于局部代码，而程序一旦跳出作用域，strongSelf就会被释放，这个临时产生的“循环引用”就会被自动打破，代码的执行事实上也是这样子的。

我们可以简单地验证一下，首先我们用到一个CoreFoundation中的一个方法CFGetRetainCount，它可以在ARC下获取retainCount，修改main函数中如下：

@autoreleasepool
{
    MyTestBlock *testBlock = [[MyTestBlock alloc] init];
    NSLog(@"block执行前：%lu",CFGetRetainCount((__bridge CFTypeRef)testBlock));
    testBlock.block();
    NSLog(@"block执行后：%lu",CFGetRetainCount((__bridge CFTypeRef)testBlock));
}

执行结果如下：

2017-02-03 13:49:34.465 myBlock[6380:4604974] block执行前：1
2017-02-03 13:49:34.466 myBlock[6380:4604974] block执行后：2
2017-02-03 13:49:39.469 myBlock[6380:4605000] ---->print
2017-02-03 13:49:39.469 myBlock[6380:4605000] ------>dealloc

我们发现block执行后，testBlock对象的retainCount加了1，说明block执行时，对testBlock对象临时加了强引用，但是最终对象顺利dealloc。

iOS开发笔记之五十七——weak与strong是如何解决循环引用的

猜你喜欢