__weak与__strong是如何解决循环引用的

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

__weak typeof(self) weakSelf =self;

self.block= ^{

__strong typeof(weakSelf) strongSelf = weakSelf;

[strongSelfprint];

};

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

#import <Foundation/Foundation.h>  
@interface MyTestBlock : NSObject  
@property (nonatomic, copy) void(^block)();  

@end

#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方法里测试它：

#import <Foundation/Foundation.h>  
#import <objc/runtime.h>  
#import "MyTestBlock.h"  
  
int main(int argc, const charchar * 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变量是可以省略的，如下：

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，添加异步逻辑如下：

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逻辑之后：

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