解决block的循环引用有两种方式：
1，通过设置__weak，可以将self指针弱引用，达到解除循环引用的作用
在block中将__weak转化为__strong，是为了执行完block才释放self，因为__strong修饰的变量时临时的强引用，在block没有执行前，self是不会被释放的，执行后,__strong临时变量销毁，self指向的对象没有了强引用，就会销毁。是否使用__strong转化根据具体需求实现。
2，通过事后补救，比如一个请求类Reqeust拥有的api实例方法有一个block回调，这个block在Request类中强引用，那么在Request请求api中请求后回调了block后将block置为nil，这样就可以避免在外部调用时写__weak 和__strong了。但是这样做只能用于一次性调用block的地方，比如一个弹出框点击事件的回调block，点击后这个弹出框就消毁了。否则第二次再点击时，block已经为nil，就不能回调了。
3，造成循环引用的地方还有代理的强引用，所以代理是要弱引用的。另外还有这样的设计，如，Person 有一个family数组成员，这个成员包含的是Person对象。
Person *person1 = [[Person alloc] init];
Person *person2 = [[Person alloc] init];
person1.family = @[person1];
person2.family = @[person2];
数组的包装会对成员函数有一个强引用，这样就存在了相互强引用的问题。person1和person2都无法释放掉。
解决方式,将family的类型范围NSHashTable:
NSHashTable *family1 = [NSHashTable hashTableWithOptions:(NSPointerFunctionsWeakMemory)];
NSHashTable *family2 = [NSHashTable hashTableWithOptions:(NSPointerFunctionsWeakMemory)];
[family1 addObject:person2];
[family2 addObject:person1];
这样NSPointerFunctionsWeakMemory类型的NSHashTable容器不会对成员的引用计数进行+1操作。
如果是通过NSDictionary来作为容器，那么需要用NSMapTable来替换。
[NSMapTable strongToWeakObjectsMapTable];可以创建一个key是强引用，value是弱引用的映射对象。
参考：https://www.jianshu.com/p/de71385930ba
4，block是一个对象，可以保存在数组中，也可以通过isEqual：进行比较。
block赋值给一个对象的属性后，和临时变量进行比较，会得出相等的结果.
@interface Person : NSObject
@property (nonatomic, copy) void (^block)(void);
@end
void (^block)(void) = ^{
NSLog(@"===");
};
Person *test = [[Person alloc] init];
void(^block1)(void) = block;
test.block = block;
if (test.block == block1) {
NSLog(@"相同");
}
else {
NSLog(@"不相同");
}
得出结果是相同的。
5，__Strong的作用:保证block方法在异步调用时能够被执行
#import "MyTestBlock.h"
@interface MyTestBlock : NSObject
@property (nonatomic, copy) void(^block)(void);
@end
@implementation MyTestBlock
- (instancetype)init {
self = [super init];
if (self) {
__weak typeof(self) weakSelf = self;
self.block = ^{
NSLog(@"开始执行了block");
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3 * NSEC_PER_SEC)), dispatch_get_global_queue(0, 0), ^{
NSLog(@"回调执行了");
[weakSelf print];
});
};
}
return self;
}
- (void)print {
NSLog(@"---print");
}
- (void)dealloc {
NSLog(@"mytestBlock dealloc");
}
@end
打印结果,可以看到当使用weak时，异步调用，weakSelf已经是nil，无法执行print方法
2018-07-11 16:38:23.801538+0800 TestOC[8097:937578] 开始执行了block
2018-07-11 16:38:23.801808+0800 TestOC[8097:937578] mytestBlock dealloc
2018-07-11 16:38:26.801794+0800 TestOC[8097:937670] 回调执行
将block中改为strongSelf
- (instancetype)init {
self = [super init];
if (self) {
__weak typeof(self) weakSelf = self;
self.block = ^{
NSLog(@"开始执行了block");
__strong typeof(weakSelf) strongSelf = weakSelf;
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3 * NSEC_PER_SEC)), dispatch_get_global_queue(0, 0), ^{
NSLog(@"回调执行了");
[strongSelf print];
});
};
}
return self;
}
打印结果:可以看出3秒后执行了print方法
2018-07-11 16:44:29.829198+0800 TestOC[8157:955329] 开始执行了block
2018-07-11 16:44:32.988705+0800 TestOC[8157:955433] 回调执行了
2018-07-11 16:44:32.988745+0800 TestOC[8157:955433] ---print
2018-07-11 16:44:32.988763+0800 TestOC[8157:955433] mytestBlock dealloc
分析:使用weak在同步执行block时，是不用使用strong的。如果是异步执行使用strong的作用是使block方法得到执行。之所以__strong有这个功能，是因为__strong是一个和self指向相同的临时指针，当block持有__strong修饰的变量时，对象不会被销毁，因为是强引用，这是其实是有循环引用的，但是当block执行过后，__strong修饰的变量自动销毁，这样这个循环引用就自动解除了，self就dealloc了
