block详解<4>: 循环引用

这个问题网上的文章实在是太多，我就大概介绍一下就好了。先看一下循环引用的例子：

@interface VC2 ()
@property (nonatomic, strong) void (^block) (void);
@end
@implementation VC

- (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view.
    self.block = ^{
        NSLog(@"%@",self);
    };
}
- (void)dealloc {
    NSLog(@"vc释放了");
}

上面的VC2是从前面push进来的，当pop出去的时候，dealloc方法并没有被调用，说明上面的block导致了循环引用。

下面我们再来看看破解循环引用的方法：就是在block要捕获的对象的前面加一个修饰符_weak.

- (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view.
    __weak typeof(self) weakSelf = self;
    self.block = ^{
        NSLog(@"%@",weakSelf);
    };
}

改为上面的写法之后，VC2在pop出去的时候，dealloc被调用了，这说明循环引用已经被打破了。下面用一张图解释一下上面的两种情况。

循环引用.png

有时候，我们在多线程的操作中，会遇到weakSelf被提前释放：

- (void)viewDidLoad {
   [super viewDidLoad];
   // Do any additional setup after loading the view.
   __weak typeof(self) weakSelf = self;
   self.block = ^{
       dispatch_async(dispatch_get_main_queue(), ^{
          [weakSelf doSomething];
       });
   };
}

- (void)viewDidDisappear:(BOOL)animated {
   [super viewDidDisappear:animated];
   self.block();
}

- (void)doSomething {
   NSLog(@"一些存储工作");
}

- (void)dealloc {
  NSLog(@"vc释放了");
}

我们发现doSomething函数并没有被调用,说明weakSelf被提前释放掉了，我们加个打印测试一下:

- (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view.
    __weak typeof(self) weakSelf = self;
    self.block = ^{
        NSLog(@"weakSelf1 = %@",weakSelf);
        dispatch_async(dispatch_get_main_queue(), ^{
            NSLog(@"weakSelf2 = %@",weakSelf);
           [weakSelf doSomething];
        });
    };
}

打印结果如下
**2016-09-23 14:58:19.851289 BlockTest5[1726:654191] weakSelf1 = <VC2: 0x100316360>**
**2016-09-23 14:58:19.852054 BlockTest5[1726:654191] vc****释放了**
**2016-09-23 14:58:19.854404 BlockTest5[1726:654191] weakSelf2 = (null)**

从打印结果可以发现，doSomething函数是在dealloc函数被调用之后调用的，这个时候weakSelf肯定已经被释放了，所以doSomething函数不可能被调用。为了避免这种情况，我们需要在block里面再强引用一次weakSelf,修改代码如下：

- (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view.
    __weak typeof(self) weakSelf = self;
    self.block = ^{
        NSLog(@"weakSelf1 = %@",weakSelf);
        __strong typeof(self) stongSelf = weakSelf;
        dispatch_async(dispatch_get_main_queue(), ^{
            NSLog(@"weakSelf2 = %@",stongSelf);
           [stongSelf doSomething];
        });
    };
}

打印结果如下:
**2016-09-23 15:03:57.843134 BlockTest5[1734:655722] weakSelf1 = <VC2: 0x1003135b0>**
**2016-09-23 15:03:57.844858 BlockTest5[1734:655722] weakSelf2 = <VC2: 0x1003135b0>**
**2016-09-23 15:03:57.845021 BlockTest5[1734:655722] ****一些存储工作**
**2016-09-23 15:03:57.845108 BlockTest5[1734:655722] vc****释放了**

从打印结果可以看出，doSomething函数是在dealloc函数调用之前调用的，所以可以正常调用。

哪些情况不需要考虑循环引用

- (void)viewDidLoad {
    [super viewDidLoad];
    
    [UIView animateWithDuration:0.25 animations:^{
        self.view.alpha = 0.5;
    }];
    
    dispatch_async(dispatch_get_main_queue(), ^{
        NSLog(@"self = %@",self);
    });
}

上面两种block是我们最常用的，在VC2 pop出去之后，dealloc正常调用，说明self可以释放，也就是上面的两种block不会造成循环引用。

再来看看我们自定义的block：类函数的block和单例函数的block

首先我们定义一个新的类叫User,里面定义了一个＋方法，然后还是在VC2中调用。

@interface User ()
@end

+ (void)method1:(void (^)(void)) block {
    block();
}
- (void)viewDidLoad {
    [super viewDidLoad];
    [User method1:^{
        NSLog(@"self = %@",self);
    }];
}

pop之后的打印结果:
**2016-09-23 15:36:06.575382 BlockTest5[1768:664071] self = <VC2: 0x100205190>**
**2016-09-23 15:36:07.750706 BlockTest5[1768:664071] vc****释放了**

因为VC2和User这个类不存在持有关系，即使block持有了VC2，在block之行完毕之后，block会自动释放VC2的引用，这个跟UIView 动画的block的一样，不会造成循环引用。

再来看看单例会不会造成循环引用

+ (User *)sharedInstance {
    static User *_sharedInstance = nil;
    static dispatch_once_t oncePredicate;
    dispatch_once(&oncePredicate, ^{
        _sharedInstance = [[User alloc] init];
    });
    return _sharedInstance;
}

- (void)method:(void (^)(void)) block {
    block();
}

- (void)viewDidLoad {
    [super viewDidLoad];
    
    [[User sharedInstance] method:^{
        NSLog(@"self = %@",self);
    }];

pop之后的打印结果:
**2016-09-23 15:48:39.269606 BlockTest5[1774:666370] self = <VC2: 0x1004175e0>**
**2016-09-23 15:48:40.482220 BlockTest5[1774:666370] vc****释放了**
}

虽然单例在生成之后不会被释放，但是单例并没有引用block，即使block引用了VC2,但是block在执行完毕之后，会释放掉VC2的引用，所以不会造成循环引用。

我们修改一下，上面的代码，让单例强引用block。

typedef void (^block) (void);

@interface User ()
@property (nonatomic, strong) block blk;
@end

- (void)method:(void (^)(void)) block {
    self.blk = block;
    block();
}

pop之后的打印结果：
**2016-09-23 15:54:05.826783 BlockTest5[1777:667593] self = <VC2: 0x1003126f0>**

从打印结果中，我们可以看出VC2的dealloc方法并没有被调用，说明出现了循环引用。
因为在这种情况下，单例引用了block，block引用了VC2,而单例在程序运行中不会被释放，所以block也不会被释放，所以VC2也不会被释放。