注释：本文通过查阅第三方资料整理
retain cycle的产生
- 说到retain cycle，首先要提一下Objective-C的内存管理机制。
- 作为C语言的超集，Objective-C延续了C语言中手动管理内存的方法，但是区分C++的极其非人道的内存管理，Objcetive-C提出了一些机制来减少内存管理的难度。比如：内存计数。
- 在Objective-C中，凡是继承自NS Object的类都提供了两种方式，retain和release。当我们调用一个对象的retain时，这个对象的内存计数加1，反之，当我们调用release时，对象的内存计数减1，只有党对象内存计数为0时，这个对象才真正会被释放，此时，对象的delloc方法会被调用来做些内存回收前的工作。
- 内存计数机制的好处在于我们可以明确分配一个使用权。
比如，当一个对象A要使用另外一个对象B的时候，A会`retain`B一次以表示A使用了B，
而当B被使用完毕之后，A会调用B的`release`方法来放弃使用权。
- 这样，一个对象可以被多个其他对象使用，而作为使用他的对象，也不必关心自己之外，被使用对象的使用情况（内存方面）。一般来讲，对于类的成员变量，retain和release分别发生在
赋值和自身释放的时候，这个就是Obj-C程序中的经典写法：
// 头文件中：
@property (nonatomic, retain) NSObjcet *obj;
// 在.m文件里：
- (void)dealloc {
[obj release];
[super dealloc];
}
- 这种方法可以很容易的管理内存，但是仍存在着一个问题，就是retain cycle
-
Retian cycle，翻译成中文大概叫“保留环”，既然父对象持有子对象，而子对象会随父对象释放而释放，那么，如果两个对象相互为父对象怎么办？
比如A和B两个对象，A持有B，B同时也持有A，按照上面的规则，
A只有B释放之后才有可能释放，同时B只有A释放了才可能释放，
当双方都在等待对方的释放时，retain cycle就形成了，
结果是，两个对象都永远不会被释放，最终内存泄漏
- retain cycle使你编程的时候不得不注意一些问题。例如，要么尽量保持子对象引用父对象的时候使用弱引用，也就是assign
@property (nonatomic, assign) NSObject *parent;
- 要么及时地将造成retain cycle中的一个变量设置为nil，将环
break掉。
举一个非常简单的循环引用的例子
NSMutableArray *arr1 = [NSMutableArray array];
NSMutableArray *arr2 = [NSMutableArray array];
[arr1 addObjectsFromArray:arr2];
[arr2 addobjectsFromArray:arr1];
- 很明显，arr1和arr2都不会被释放，因为她们相互持有。
- 也是因此，
代理属性要声明为assign或者weak，那同时，block也要注意循环引用。
为什么代理要用weak或assign？
- 我们在ViewController.h中声明一个委托，并写一个代理属性。
@protocol ViewControllerDelegate<NSObject>
@optional
- (void)method;
@end
@interface ViewController : UIViewController
@property (nonatomic, weak) id<ViewControllerDelegate> delegate;
@end
- 然后在ViewController.m中调用代理
if ([self.delegate respondsToSelector:@selector(method)]) {
[self.delegate method];
}
- 在SecondViewController.m中遵守协议，并成为ViewController的代理，实现代理方法
#import "SecondViewController.h"
#import "ViewController.h"
@interface SecondViewController () <ViewControllerDelegate>
@end
@implementation SecondViewController
- (void)viewDidLoad {
[super viewDidLoad];
ViewController *viewVC = [[ViewController alloc] init];
viewVC.delegate = self;
[self.view addSubview:viewVC.view];
}
- (void)method {
NSLog(@"method");
}
- 上面这段代码的重点是，
viewVC.delegate = self;这一行代码，这时，我们会看在ViewController中的代理属性@property (nonatomic, weak) id delegate;相当于这个id类型现在就是SecondViewController类型，换句话说，就是ViewController对SecondViewController进行了引用，这里是weak，所以是弱引用。而SecondViewController对ViewController进行了强引用。所以，如果delegate属性声明为strong，就会造成循环引用。
Block造成的引用循环
- 在编码中，由于block可以引用外部环境，于是我们对block的使用不慎，也可能导致引用循环，下面让我们分析一下在MRC以及ARC环境下，由block所引起引用循环
<h5>MRC</h5>
- <h6>假如我有一个manager实例，实例中有一个block的属性</h6>
- block运行时，会隐式retain它所用刀的变量
DoSomethingManager *manager = [[DoSomethingManager alloc] init];
manager.complete = ^{
// ... complete actions
[manager otherAction];
[manager release];
};
这样子就造成manager和它的complete block相互持有，导致
引用循环正确的做法应该是，block中把manager里的complete block置nil，在释放自己，就可以破坏引用循环。
DoSomethingManager *manager = [[DoSomethingManager alloc] init];
manager.complete = ^{
// ... complete actions
[manager otherAction];
manager.complete = nil;
[manager release];
}
<h5>MRC</h5>
- ARC环境下，在block中也会引入retain cycle，只是结局方法除了上面所提到的方法外，还有别的方法解决以及预防block中retain cycle
- 比如：在ARC中，引入了三个心的所有权修饰符
1. __strong : 修饰的变量会自动被retain一次，并且在block中也会被retain一次
2. __unsafe_unretained : 修饰的变量不会被retain，但在block运行中无法控制他的生命周期，可能block在运行过程中，它已经被释放了，留下一个野指针
3. __weak : 修饰的变量一样不会被retain，它修饰的变量的生命周期同样无法被block控制，但是好在它修饰的指针指向的内存在被系统释放后，它会置nil，这样就会安全许多。
- 在这里提一下，id类型和对象类型的所有权修饰符默认为__strong修饰符。即我们随手创建的队形，只要不特别声明，就是一个强引用。
- 事实上，还有两个所有权修饰符——即：
1. __autoreleasing，但是这个修饰符非本文所讨论的范围
2. __block，等下再来讨论这个修饰符
- 说回解决上述问题的retain cycle的新方法（ARC中）：
DoSomethingManager *manager = [[DoSomethingManager alloc] init];
// manager actions
__weak DoSomethingManager *weakManager = manager;
manager.complete = ^{
// ... complete actions
[weakManager otherAction];
};
- 接下来我们来看一个新的解决block中的循环引用的办法吧！（用到__block关键字）
__block DoSomethingManager *manager = [[DoSomethingManager alloc] init];
manager.coplete = ^{
// ...complete actions
[manager otherAction];
manager = nil;
};
- 如果不用ARC，manager不会在block中被retain，但是在ARC中，情况就有点复杂了。
- 由于__block变量保存更为底层的地址，那么，当__block变量指向别的对象的时候，引发的情况就是，block不再对原来的变量负责，导致之前的对象release掉，而retain cycle就被破坏掉了。
- 下面附上两篇关于retain cycle的好文：
