什么是循环引用？就是两个或多个对象之间，都是强引用，且对象之间的引用形成了一个环状结构。导致对象最终无法释放，造成内存泄露。
为什么循环引用就会导致对象无法释放呢？先看一个小例子：
@interface A : NSObject
@property (nonatomic, strong) B *b;
@end
@interface B : NSObject
@property (nonatomic, strong) A *a;
@end
@implementation A
- (instancetype) init {
NSLog(@"%s", __FUNCTION__);
return [super init];
}
- (void)dealloc {
NSLog(@"%s", __FUNCTION__);
}
@end
@implementation B
- (instancetype) init {
NSLog(@"%s", __FUNCTION__);
return [super init];
}
- (void)dealloc {
NSLog(@"%s", __FUNCTION__);
}
@end
//使用A、B对象造成循环引用
- (void)viewDidLoad {
[super viewDidLoad];
A *a = [[A alloc] init]; //创建对象a，a的引用计数为1
a.b = [[B alloc] init]; //对象a强引用对象b，b的引用计数为1
a.b.a = a; //对象b强引用对象a，a的引用计数为2
}
运行结果：
2017-09-04 16:06:11.326 RetainCycleDemo[25202:24312629] -[A init]
2017-09-04 16:06:11.326 RetainCycleDemo[25202:24312629] -[B init]
通过运行结果可以看到，对象a和对象b的dealloc都没有调用，说明a、b都没有释放。参见上图，表示了a、b的引用情况。代码中的注释表示了a、b的引用计数情况，当a离开作用域时，a的引用计数减1，但此时，a的引用计数并没有变为0，所以并不会释放。
这个问题该怎样解决？
这个问题的关键在于让a离开作用域时，a的引用计数为1。
方法一:
- (void)viewDidLoad {
[super viewDidLoad];
A *a = [[A alloc] init];
a.b = [[B alloc] init];
a.b.a = a;
a.b = nil; //在a离开作用域前，将b置为nil，此时b会释放，同时会将a的引用计数减1
NSLog(@"b的dealloc 应该执行了吧"); //在此加断点，会发现b的dealloc已经执行
}
运行结果:
2017-09-04 23:16:46.918 demo1[22614:63060544] -[B dealloc]
2017-09-04 23:17:19.716 demo1[22614:63060544] b的dealloc 应该执行了吧
2017-09-04 23:17:19.716 demo1[22614:63060544] -[A dealloc]
方法二:
@interface B : NSObject
@property (nonatomic, weak) A *a; //将属性设为weak，弱引用对象a
@end
- (void)viewDidLoad {
[super viewDidLoad];
A *a = [[A alloc] init];
a.b = [[B alloc] init];
a.b.a = a; //因为b对a是弱引用，所以不会增加a的引用计数
}
运行结果:
2017-09-04 23:21:52.524 demo1[23489:63076174] -[A dealloc]
2017-09-04 23:21:52.524 demo1[23489:63076174] -[B dealloc]
block循环引用
循环引用通常是block导致的，如下面的例子：
例1:TableViewCell的block回调
//自定义cell，cell中有个按钮，当点击按钮时，通过block通知VC
//MyCell.h
@interface MyCell : UITableViewCell
@property (nonatomic, copy) void(^cellBtnClickBlock)();
@end
//MyCell.m
@implementation MyCell
- (IBAction)cellBtnClick:(id)sender {
self.cellBtnClickBlock();
}
@end
//ViewController.m
//点击cell的button，然后通过导航栏返回到上层控制器，看dealloc是否被调用
- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath {
MyCell *cell = [tableView dequeueReusableCellWithIdentifier:NSStringFromClass([MyCell class]) forIndexPath:indexPath];
cell.cellBtnClickBlock = ^{
NSLog(@"%s, %@", __FUNCTION__, self);
};
return cell;
}
- (void)dealloc {
NSLog(@"%s", __FUNCTION__);
}
运行结果：2017-09-06 09:31:28.365 RetainCycleDemo[28479:29994003] -[ViewController tableView:cellForRowAtIndexPath:]_block_invoke, <ViewController: 0x7fbd4ac29ca0>
通过运行结果可以看到,dealloc并没有被调用，说明发生了循环引用。上图中表示了对象之间的引用情况。要打破这个循环，则需要在cell里不强引用self。代码如下：
- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath {
MyCell *cell = [tableView dequeueReusableCellWithIdentifier:NSStringFromClass([MyCell class]) forIndexPath:indexPath];
__weak typeof(self) weakSelf = self;
cell.cellBtnClickBlock = ^{
NSLog(@"%s, %@", __FUNCTION__, weakSelf);
};
return cell;
}
运行工程，结果OK，如下：
例2:NSNotification 的循环引用
@implementation SecondViewController
- (void)addObserver {
[[NSNotificationCenter defaultCenter] addObserverForName:@"noticycle" object:nil queue:[NSOperationQueue mainQueue] usingBlock:^(NSNotification * _Nonnull note) {
NSLog(@"%s, %@", __FUNCTION__, self);
}];
}
- (void)postNotification {
[[NSNotificationCenter defaultCenter] postNotificationName:@"noticycle" object:nil];
NSLog(@"%s, %@", __FUNCTION__, self);
}
@end
@implementation FirstViewController
- (void)viewDidLoad {
[super viewDidLoad];
// Do any additional setup after loading the view.
//创建两个SecondViewController对象，VC1做观察者，VC2做通知发送者
SecondViewController *VC1 = [[SecondViewController alloc] init];
VC1.title = @"VC1";
[VC1 addObserver];
SecondViewController *VC2 = [[SecondViewController alloc] init];
VC2.title = @"VC2";
[VC2 postNotification];
}
@end
运行结果：
2017-09-06 12:31:17.710 RetainCycleDemo[58071:30501179] -[SecondViewController addObserver]_block_invoke, VC1
2017-09-06 12:31:17.710 RetainCycleDemo[58071:30501179] -[SecondViewController postNotification], VC2
2017-09-06 12:31:17.712 RetainCycleDemo[58071:30501179] -[SecondViewController dealloc], VC2
从运行结果可以看到,VC1并没有得到释放。解决方式，同样是在addObserverForName的block中使用weakSelf方式，解决循环引用的问题。
But：这里我也没弄懂的是，addObserverForName方法中不需要传入self，是怎样持有的self呢？还请大家指点。
补充：这个问题我专门写了一篇文章：NSNotification引起的内存泄漏和循环引用，欢迎大家一起探讨
使用block的地方有很多，但并不是所以block都会产生循环引用，如以下情况：
例3：使用系统自带的UIView 的block，如下图所示，虽然在animation的block中打印了self，但由于是类方法，self并没有对block有强引用，所以不会形成循环引用。
同样类似的还有GCD系列，如下面也不会产生循环引用:
dispatch_async(dispatch_get_global_queue(0, 0), ^{
NSLog(@"dispatch_async：%@", self);
});
例4：NSURLSession的block，我们可以直接适用sharedSession来进行HTTP请求，或自己创建session，但不管是不是自己持有的session，都不会造成循环引用
注意：session使用的是sharedSession，而不是通过sessionWithConfiguration: delegate: delegateQueue:创建的，其中区别，请看例5中AFN的讲解
例5：AFN的block，AFN的block比较特殊，让我们慢慢道来，首先看一下使用及结果。
如上图所示，通过实例验证了AFN确实不会引起循环引用，VC得到了正常的释放，AFN的内部处理逻辑如下：
//单步跟踪会发现在真正调用系统NSURLSession的dataTaskWithRequest之后，调用了下面方法
- (void)addDelegateForDataTask:(NSURLSessionDataTask *)dataTask
uploadProgress:(nullable void (^)(NSProgress *uploadProgress)) uploadProgressBlock
downloadProgress:(nullable void (^)(NSProgress *downloadProgress)) downloadProgressBlock
completionHandler:(void (^)(NSURLResponse *response, id responseObject, NSError *error))completionHandler
{
//创建一个代理类，用来保存传入的block
AFURLSessionManagerTaskDelegate *delegate = [[AFURLSessionManagerTaskDelegate alloc] initWithTask:dataTask];
delegate.manager = self;
delegate.completionHandler = completionHandler;//completionHandler被强引用
dataTask.taskDescription = self.taskDescriptionForSessionTasks;
[self setDelegate:delegate forTask:dataTask];//将代理类保存起来，见下面代码实现
delegate.uploadProgressBlock = uploadProgressBlock;
delegate.downloadProgressBlock = downloadProgressBlock;//download被强引用
}
- (void)setDelegate:(AFURLSessionManagerTaskDelegate *)delegate
forTask:(NSURLSessionTask *)task
{
NSParameterAssert(task);
NSParameterAssert(delegate);
[self.lock lock];
//以task.taskIdentifier为key，将代理类保存起来，即将上面的block强引用
self.mutableTaskDelegatesKeyedByTaskIdentifier[@(task.taskIdentifier)] = delegate;
[self addNotificationObserverForTask:task];
[self.lock unlock];
}
#pragma mark - NSURLSessionTaskDelegate
//任务完成会NSURLSession会调用该代理函数
- (void)URLSession:(NSURLSession *)session
task:(NSURLSessionTask *)task
didCompleteWithError:(NSError *)error
{
//根据task.taskIdentifier找到对应的代理类
AFURLSessionManagerTaskDelegate *delegate = [self delegateForTask:task];
// delegate may be nil when completing a task in the background
if (delegate) {
//代理类将本次http请求的结果，通过保存的block返回给调用者
[delegate URLSession:session task:task didCompleteWithError:error];
//移除对block的强引用，由于在block执行完之后已经移除了自身对block的引用，所以便打破了这个循环引用
[self removeDelegateForTask:task]; //如果将这行注释掉，会发现VC不会释放
}
if (self.taskDidComplete) {
self.taskDidComplete(session, task, error);
}
}
通过上面的代码和图示，清楚的表示了AFN如何打破的VC和AFN之间的循环引用。即AFN在调用完block之后，取消了对block的强引用，切断了这个环。
ps:可以猜想，例4中虽然VC持有NSURLSession对象，但并不会造成循环引用，可能也是通过这种方式来解决的。
乍看之下，这个问题得到了很好的解决，貌似已经没有任何问题。我们稍微改动下代码，让VC不持有AFN，并且注释AFN删除delegate这行代码，即让AFN单向持有VC，如下图所示：
通过上图运行结果可见，VC没有对AFN的强引用，但VC并没有得到释放。这是为什么呢？难道我们上面的分析有误？下面我们从AFN的创建来分析一下：
AFN创建对象时，对于
NSURLSession的创建，使用了sessionWithConfiguration: delegate: delegateQueue:方法，并将AFURLSessionManager对象赋值到delegate中，如下：
看图中Important部分，
session对传入的delegate对象保持一个强引用直到app退出，或调用invalidateAndCancel或finishTasksAndInvalidate方法使session失效。否则就会造成内存泄漏。即AFN和session之间是存在循环引用的。所以，当创建一个临时的AFN对象发起请求时，发起方(假设为VC)和AFN之间的引用关系为(此时AFN删除delegate这行代码仍被注释掉)：
所以，上面将
removeDelegateForTask:注释掉之后，是由于AFN对象得不到释放，导致AFN对block还保持有强引用，block又对VC有强引用，才会导致VC释放不掉。
*************下面恢复注释掉的代码，使AFN为标准未改动过的代码*************
如果在VC中持有AFN的对象，像本例刚开始一样，那么对象之间的引用情况如下：
AFN在调用block回调之后，清除了AFN对block的引用，打破了VC和AFN之间的循环引用。使VC可以正常释放。但需要注意的是，AFN对象并没有得到释放，内存泄漏依然是存在的！！
在实际开发中，我们通常不会在VC中持有AFN对象，而是会将AFN封装，所以，AFN对象的创建可能是单例或有限个，但依然需要关注内存泄漏的情况。
