最近在查阅一些第三方库的源码时，发现了这么一段代码
__weak typeof(self) weakself = self;
delay(time, ^{
__strong typeof(weakself) strongSelf = weakself;
if (strongSelf) {
[strongSelf hide];
}
});
还有在AFNetWorking中
__weak __typeof(self)weakSelf = self;
AFNetworkReachabilityStatusBlock callback = ^(AFNetworkReachabilityStatus status) {
__strong __typeof(weakSelf)strongSelf = weakSelf;
strongSelf.networkReachabilityStatus = status;
if (strongSelf.networkReachabilityStatusBlock) {
strongSelf.networkReachabilityStatusBlock(status);
}
};
在ARC环境下，我们经常会使用__weak 的修饰符来修饰一个变量，防止其在block中被循环引用的情况发生，但是有些特殊情况下，我们在block中又使用__strong 来修饰这个在block外刚刚用__weak修饰的变量。
经过查询，还是找到了这么一篇文章
转自唐巧的关于__weak和__strong详解
文中大概是这么解释的
在block中调用self会引起循环引用，但是在block中需要对weakSelf进行strong,保证代码在执行到block中，self不会被释放，当block执行完后，会自动释放该strongSelf。
在 block 中先写一个 strong self，其实是为了避免在 block 的执行过程中，突然出现 self 被释放的尴尬情况。通常情况下，如果不这么做的话，还是很容易出现一些奇怪的逻辑。
1.概念
__strong的概念
__strong修饰符是id类型和对象类型默认的所有权修饰符。
__strong修饰符表示对对象的强引用，持有强引用的变量在出其作用域时被废弃，随着强引用的失效，引用的对象随之释放。
__weak的概念
__weak 解决循环引用，带有__weak修饰符的变量不持有对象，所以在超出其变量作用域时，对象即被释放。
在解释上述代码时，还是先通过代码来理解下这两种修饰符的不同。
1.创建一个person类
2.实例化person,并给与修饰符__weak
person * p1 = [[person alloc]init];
__weak person * p2 = p1;
p1 = nil;
NSLog(@"__weak修饰 p1=%@ p2=%@",p1,p2);
打印结果
__weak修饰 p1=(null)p2=(null)
我们通过代码可以得出
当p1设为nil后，__weak修饰的p2也为nil.
我们来使用修饰符__strong
person * p1 = [[person alloc]init];
__strong person* p2 = p1;
p1 = nil;
NSLog(@"__strong修饰 p1=%@ p2=%@",p1,p2);
打印结果
__strong修饰 p1=(null) p2=<person: 0x604000013060>
可以看到
当p1设为nil后，__strong修饰的p2仍然存在。
我们还是重现下文中前两段代码的使用方法
1.在person类中，dealloc方法中
-(void)dealloc
{
NSLog(@"dealloc -- 方法调用%@",[self class]);
}
2.使用__weak修饰，每隔1s打印一次，3s后将p1置为nil
#import "ViewController.h"
#import "person.h"
@interface ViewController ()
@property (nonatomic,strong) person * p1;
@end
@implementation ViewController
- (void)viewDidLoad {
[super viewDidLoad];
person* p1 = [[person alloc]init];
self.p1= p1;
__weak person* weakp2 = self.p1;
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0), ^{
NSInteger count =0;
// __strong person* strongP2 = weakp2;
while(count<5) {
count++;
// 阻塞一秒执行一次
NSLog(@"__weak 修饰 %@",weakp2);
// NSLog(@"__strong修饰 %@",strongP2);
sleep(1);
}
});
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2*NSEC_PER_SEC)),dispatch_get_main_queue(), ^{
self.p1= nil;
});
}
打印结果如下
2018-03-25 12:56:57.338597+0800 testCode[72562:3533996] __weak 修饰 <person: 0x60000000bdf0>
2018-03-25 12:56:58.342259+0800 testCode[72562:3533996] __weak 修饰 <person: 0x60000000bdf0>
2018-03-25 12:56:59.338610+0800 testCode[72562:3533876] dealloc -- 方法调用person
2018-03-25 12:56:59.347271+0800 testCode[72562:3533996] __weak 修饰 (null)
2018-03-25 12:57:00.348689+0800 testCode[72562:3533996] __weak 修饰 (null)
2018-03-25 12:57:01.352773+0800 testCode[72562:3533996] __weak 修饰 (null)
我们可以得到，只使用__weak去修饰变量，当别处把变量释放后，block中该变量也会被释放掉。
接下来我们在__block的方法内部加上__strong修饰符
- (void)viewDidLoad {
[super viewDidLoad];
person* p1 = [[person alloc]init];
self.p1= p1;
__weak person* weakp2 = self.p1;
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0), ^{
NSInteger count =0;
__strong person* strongP2 = weakp2;
while(count<5) {
count++;
// 阻塞一秒执行一次
NSLog(@"__strong修饰 %@",strongP2);
sleep(1);
}
});
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2*NSEC_PER_SEC)),dispatch_get_main_queue(), ^{
self.p1= nil;
});
}
打印结果如下
2018-03-25 13:02:21.385418+0800 testCode[72600:3537337] __strong修饰 <person: 0x6040000106a0>
2018-03-25 13:02:22.388769+0800 testCode[72600:3537337] __strong修饰 <person: 0x6040000106a0>
2018-03-25 13:02:23.391824+0800 testCode[72600:3537337] __strong修饰 <person: 0x6040000106a0>
2018-03-25 13:02:24.395673+0800 testCode[72600:3537337] __strong修饰 <person: 0x6040000106a0>
2018-03-25 13:02:25.399132+0800 testCode[72600:3537337] __strong修饰 <person: 0x6040000106a0>
2018-03-25 13:02:26.402472+0800 testCode[72600:3537337] dealloc -- 方法调用person
在__block中修饰后的方法中，再加上修饰符strong时，当别处把变量释放掉，但调用该变量的block如果仍然没有执行结束，那么系统就会等待block执行完成后再释放，对该变量在block中的使用起到了保护作用。当block执行结束后会自动释放掉。
本文代码及结论参考 骨头 的一篇文章
block 中使用__weak 和__strong修饰符的问题
