Block及循环引用

解决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了