本文主要介绍ARC下block的循环引用问题，举例说明引起循环引用的场景和相应的解决方案。
在讲block的循环引用问题之前，我们需要先了解一下iOS的内存管理机制和block的基本知识
iOS的内存管理机制
Objective-C在iOS中不支持GC(垃圾回收)机制，而是采用的引用计数的方式管理内存。
引用计数(Reference Count)
在引用计数中，每一个对象负责维护对象所有引用的计数值。当一个新的引用指向对象时，引用计数器就递增，当去掉一个引用时，引用计数就递减。当引用计数到零时，该对象就将释放占有的资源。
我们通过开关房间的灯为例来�说明引用计数机制。
图中，“需要照明的人数”即对应我们要说的引用计数值。
- 第一个人进入办公室，“需要照明的人数”加1，计数值从0变为1，因此需要开灯；
- 之后每当有人进入办公室，“需要照明的人数”就加1。如计数值从1变成2；
- 每当有人下班离开办公室，“需要照明的人数”加减1如计数值从2变成1；
- 最后一个人下班离开办公室时，“需要照明的人数”减1。计数值从1变成0，因此需要关灯。
在Objective-C中，”对象“相当于办公室的照明设备，”对象的使用环境“相当于进入办公室的人。上班进入办公室的人对办公室照明设备发出的动作，与Objective-C中的对应关系如下表
| 对照明设备所做的动作 | 对Objective-C对象所做的动作 |
|---|---|
| 开灯 | 生成对象 |
| 需要照明 | 持有对象 |
| 不需要照明 | 释放对象 |
| 关灯 | 废弃对象 |
使用计数功能计算需要照明的人数，使办公室的照明得到了很好的管理。同样，使用引用计数功能，对象也就能得到很好的管理，这就是Objective-C内存管理，如下图所示
MRC(Manual Reference Counting)中引起应用计数变化的方法
| Objective-C对象方法 | 说明 |
|---|---|
| alloc/new/copy/mutableCopy | 创建对象，引用计数加1 |
| retain | 引用计数加1 |
| release | 引用计数减1 |
| dealloc | 当引用计数为0时调用 |
| [NSArray array] | 引用计数不增加，由自动释放池管理 |
| [NSDictionary dictionary] | 引用计数不增加，由自动释放池管理 |
自动释放池
关于自动释放，不是本文的重点，这里就不讲了。
ARC(Automatic Reference Counting)中内存管理
| Objective-C对象所有权修饰符 | 说明 |
|---|---|
| __strong | 对象默认修饰符，对象强引用，在对象超出作用域时失效。其实就相当于retain操作，超出作用域时执行release操作 |
| __weak | 弱引用，不持有对象，对象释放时会将对象置nil。 |
| __unsafe_unretained | 弱引用，不持有对象，对象释放时不会将对象置nil。 |
| __autoreleasing | 自动释放，由自动释放池管理对象 |
block的基本知识
block的基本知识这里就不细说了，可以看看我的文章说说Objective-C中的block
循环引用问题
两个对象相互持有，这样就会造成循环引用，如下图所示
图中，对象A持有对象B，对象B持有对象A，相互持有，最终导致两个对象都不能释放。
block中循环引用问题
由于block会对block中的对象进行持有操作,就相当于持有了其中的对象，而如果此时block中的对象又持有了该block，则会造成循环引用。如下，
typedef void(^block)();
@property (copy, nonatomic) block myBlock;
@property (copy, nonatomic) NSString *blockString;
- (void)testBlock {
self.myBlock = ^() {
//其实注释中的代码，同样会造成循环引用
NSString *localString = self.blockString;
//NSString *localString = _blockString;
//[self doSomething];
};
}
注：以下调用注释掉的代码同样会造成循环引用，因为不管是通过self.blockString还是_blockString，或是函数调用[self doSomething]，因为只要 block中用到了对象的属性或者函数，block就会持有该对象而不是该对象中的某个属性或者函数。
当有someObj持有self对象，此时的关系图如下。
当someObj对象release self对象时，self和myblock相互引用，retainCount都为1，造成循环引用
解决方法：
__weak typeof(self) weakSelf = self;
self.myBlock = ^() {
NSString *localString = weakSelf.blockString;
};
使用__weak修饰self，使其在block中不被持有，打破循环引用。开始状态如下
当someObj对象释放self对象时，Self的retainCount为0，走dealloc，释放myBlock对象，使其retainCount也为0。
其实以上循环引用的情况很容易发现，因为此时Xcode就会报警告。而发生在多个对象间的时候，Xcode就检测不出来了，这往往就容易被忽略。
//ClassB
@interface ClassB : NSObject
@property (strong, nonatomic) ClassA *objA;
- (void)doSomething;
@end
//ClassA
@property (strong, nonatomic) ClassB *objB;
@property (copy, nonatomic) block myBlock;
- (void)testBlockRetainCycle {
ClassB* objB = [[ClassB alloc] init];
self.myBlock = ^() {
[objB doSomething];
};
objB.objA = self;
}
解决方法：
- (void)testBlockRetainCycle {
ClassB* objB = [[ClassB alloc] init];
__weak typeof(objB) weakObjB = objB;
self.myBlock = ^() {
[weakObjB doSomething];
};
objB.objA = self;
}
将objA对象weak，使其不在block中被持有
注：以上使用__weak打破循环的方法只在ARC下才有效，在MRC下应该使用__block
或者，在block执行完后，将block置nil，这样也可以打破循环引用
- (void)testBlockRetainCycle {
ClassB* objB = [[ClassB alloc] init];
self.myBlock = ^() {
[objB doSomething];
};
objA.objA = self;
self.myBlock();
self.myBlock = nil;
}
这样做的缺点是，block只会执行一次，因为block被置nil了，要再次使用的话，需要重新赋值。
一些不会造成循环引用的block
在开发工程中，发现一些同学并没有完全理解循环引用，以为只要有block的地方就会要用__weak来修饰对象，这样完全没有必要，以下几种block是不会造成循环引用的。
大部分GCD方法
dispatch_async(dispatch_get_main_queue(), ^{
[self doSomething];
});
因为self并没有对GCD的block进行持有，没有形成循环引用。目前我还没碰到使用GCD导致循环引用的场景，如果某种场景self对GCD的block进行了持有，则才有可能造成循环引用。
block并不是属性值，而是临时变量
- (void)doSomething {
[self testWithBlock:^{
[self test];
}];
}
- (void)testWithBlock:(void(^)())block {
block();
}
- (void)test {
NSLog(@"test");
}
这里因为block只是一个临时变量，self并没有对其持有，所以没有造成循环引用
block使用对象被提前释放
看下面例子，有这种情况，如果不只是ClassA持有了myBlock，ClassB也持有了myBlock。
当ClassA被someObj对象释放后
此时，ClassA对象已经被释放，而myBlock还是被ClassB持有，没有释放；如果myBlock这个时被调度，而此时ClassA已经被释放，此时访问的ClassA将是一个nil对象（使用__weak修饰，对象释放时会置为nil），而引发错误。
另一个常见错误使用是，开发者担心循环引用错误（如上所述不会出现循环引用的情况），使用__weak。比如
__weak typeof(self) weakSelf = self;
dispatch_async(dispatch_get_main_queue(), ^{
[weakSelf doSomething];
});
因为将block作为参数传给dispatch_async时，系统会将block拷贝到堆上，而且block会持有block中用到的对象，因为dispatch_async并不知道block中对象会在什么时候被释放，为了确保系统调度执行block中的任务时其对象没有被意外释放掉，dispatch_async必须自己retain一次对象（即self），任务完成后再release对象（即self）。但这里使用__weak，使dispatch_async没有增加self的引用计数，这使得在系统在调度执行block之前，self可能已被销毁，但系统并不知道这个情况，导致block执行时访问已经被释放的self，而达不到预期的结果。
注：如果是在MRC模式下，使用__block修饰self,则此时block访问被释放的self，则会导致crash。
该场景下的代码
// ClassA.m
- (void)test {
__weak MyClass* weakSelf = self;
double delayInSeconds = 10.0f;
dispatch_time_t popTime = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(delayInSeconds * NSEC_PER_SEC));
dispatch_after(popTime, dispatch_get_main_queue(), ^(void){
NSLog(@"%@", weakSelf);
});
}
// ClassB.m
- (void)doSomething {
NSLog(@"do something");
ClassA *objA = [[ClassA alloc] init];
[objA test];
}
运行结果
[5988:435396] do something
[5988:435396] self:(null)
解决方法：
对于这种场景，就不应该使用__weak来修饰对象，让dispatch_after对self进行持有，保证block执行时self还未被释放。
block执行过程中对象被释放
还有一种场景，在block执行开始时self对象还未被释放，而执行过程中，self被释放了，此时访问self时，就会发生错误。
对于这种场景，应该在block中对 对象使用__strong修饰，使得在block期间对 对象持有，block执行结束后，解除其持有。
- (void)testBlockRetainCycle {
ClassA* objA = [[ClassA alloc] init];
__weak typeof(objA) weakObjA = objA;
self.myBlock = ^() {
__strong typeof(weakObjA) strongWeakObjA = weakObjA;
[strongWeakObjA doSomething];
};
objA.objA = self;
}
注：此方法只能保证在block执行期间对象不被释放，如果对象在block执行执行之前已经被释放了，该方法也无效。
