这个问题网上的文章实在是太多，我就大概介绍一下就好了。先看一下循环引用的例子：
@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被调用了，这说明循环引用已经被打破了。下面用一张图解释一下上面的两种情况。
有时候，我们在多线程的操作中，会遇到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也不会被释放。
