iOS中的retain cycle

注释：本文通过查阅第三方资料整理

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的好文：

1. ARC中Retain Cycle揭秘.
2. 内存管理，WEAK 和 UNOWNED