虽然目前IOS都普遍使用了ARC开发，但是还是有一些情况下是必然存在循环引用的，为了更好的说明循环引用。先以MRC的代码来描述一些内存关系。
@interface ViewController ()
@end
@implementation ViewController
(void)open{
//av 引用计数 1
AViewController *av = [[AViewController alloc] init];
// presentViewController的时候 AViewController引用计数 2
[self presentViewController:av animated:YES completion:^{
}];
// 这里释放一次 AViewController 引用计数 1
[av release];
}(void)addButton{
UIButton *button = [UIButton buttonWithType:UIButtonTypeCustom];
button.backgroundColor = [UIColor redColor];
button.frame = CGRectMake(100, 100, 100, 100);
[button addTarget:self action:@selector(open) forControlEvents:UIControlEventTouchUpInside];
[self.view addSubview:button];
}(void)viewDidLoad {
[super viewDidLoad];
[self addButton];
}
@end
这里我们看到 AViewController *av 的引用计数是1, 以下是 AViewController 的代码
@implementation AViewController
(void)back{
// AViewController 引用计数-1 (正常情况的话会形成 0)
[self dismissViewControllerAnimated:YES completion:^{
}];
}(void)viewDidLoad {
[super viewDidLoad];
}
@end
正常逻辑下 当我们 调用 back 的时候 这个时候 AViewController 会因为 dismissViewControllerAnimated 使得引用计数变成0，然后完成正常的内存释放。
这个时候我们入一个 BClass 先看 BClass的定义
@protocol BClassDelegate <NSObject>
- (void)finished;
@end
@interface BClass : NSObject
@property (nonatomic, retain) id delegate; - (void)startAnimation;
@end
注意 delegate 是 retain 关键点来了。这种设计摆明了跟其他 委托模式不一样(参考UITableView 的 delegate 是assign[因为目前是MRC 所以不是weak])。
这个时候 在 AViewController 使用 BClass。
@interface AViewController ()
@property (nonatomic, retain) BClass *animation;
@end
(void)userBClass{
//tempAnimation 引用计数 1
_animation = [[BClass alloc] init];
//关键点(这里 AViewController 引用计数变成了 2)
_animation.delegate = self;
}(void)viewDidLoad {
[super viewDidLoad];
[self userBClass];
}
为了降低复杂度 我们先只考虑AViewController 的内存释放，先暂时放下 animation的内存释放问题。
这里重点情况是 _animation.delegate = self; 这里会使得AViewController 引用计数变成2。
看下 BClass 源码
@implementation BClass
- (void)dealloc{
NSLog(@"%s", func);
[_delegate release];
_delegate = nil;
[super dealloc];
} - (void)startAnimation{
}
// 这里传进来的 adelegate 是 AViewController - (void)setDelegate:(id)adelegate{
[_delegate release];
[adelegate retain]; //关键的一部使得这个引用计数 + 1 AViewController(引用计数变成2)
_delegate = adelegate;
}
@end
关键点是因为 delegate 设计成 retain类型，所以 _animation.delegate = self; 这句代码使得 AViewController 变成了2,
这个时候 dismissViewControllerAnimated 引用计数减1, 但是 AViewController 引用计数没有变成0，所以AViewController内存没有释放，这就造成内存泄漏。到这里给出完整BClass的代码
@interface AViewController ()
@property (nonatomic, retain) BClass *animation;
@end
@implementation AViewController
(void)dealloc
{
[_animation release];
_animation = nil;
[super dealloc];
}(void)back{
// AViewController 引用计数-1 (正常情况的话会形成 0)
[self dismissViewControllerAnimated:YES completion:^{
}];
}(void)userBClass{
//tempAnimation 引用计数 1
_animation = [[BClass alloc] init];
//关键点(这里 AViewController 引用计数变成了 2)
_animation.delegate = self;
}
这里因为 back的时候 我们没有办法使得AViewController引用计数变成0，所以没有调用AViewController的dealloc，所以无法
触发 [_animation release]; 进而使得 BClass也没有被释放内存。这里就是循环引用了。
解决方案可以这样考虑，只要在调用back之前我们能够使得 AViewController的引用计数由2变成1就可以了。
这个时候改写back
- (void)back{
// 先使得AViewController 引用计数-1
[_animation.delegate release];
// AViewController 引用计数-1 (正常情况的话会形成 0)
[self dismissViewControllerAnimated:YES completion:^{
}];
}
这样就可以在调用back的时候 我们的AViewController引用计数减了2次,这种写法非常丑陋，虽然能够解决问题，但是不够方便。
参考网络上有一种通过Proxy来处理这种循环引用的 先看下TestProxy的定义
@interface TestProxy : NSProxy
@property (nonatomic, assign) id target;
@end
@implementation TestProxy
(void)dealloc{
[super dealloc];
}(NSMethodSignature*)methodSignatureForSelector:(SEL)selector
{
NSMethodSignature *signature = [_target methodSignatureForSelector:selector];
return signature;
}(void)forwardInvocation:(NSInvocation *)invocation{
SEL sel = invocation.selector;
if (_target) {
if ([_target respondsToSelector:sel]) {
[invocation invokeWithTarget:_target];
}
}
}
@end
这里可以先忽略 methodSignatureForSelector 和 forwardInvocation 先重点放在内存泄漏上。
引入TestProxy后，改写AViewController里面的userBClass和dealloc，back
(void)dealloc
{
[_animation release];
[_proxy release];
[super dealloc];
}(void)back{
[self dismissViewControllerAnimated:YES completion:^{
}];
}(void)userBClass{
//_animation 引用计数1
_animation = [[BClass alloc] init];
// _proxy 引用计数1
_proxy = [TestProxy alloc];
// _proxy 引用计数2
_animation.delegate = _proxy;
}
重点是 _animation.delegate = _proxy 这里并没有引起AViewController 引用计数的改变，所以 back的时候 AViewController能正常释放内存。所以 back触发的时候 会进入 dealloc 这个时候 [_animation release]; 会使得_animation引用计数变成了0。
到这里我们能够正常释放了 AViewController和BClass了。剩下只有能解决NSProxy正常释放那么就能够解决所有的内存泄漏问题了。 目前 proxy引用计数是2，参考代码可以知道 AViewController 的 dealloc 有一次 [_proxy release], BClass里面有一个
[_delegate release], BClass里面的delegate就是_proxy 所以 TestProxy的引用计数变成0，最终 AViewController, BClass 和 TestProxy 出现的3个类都成功完成内存释放。
对比原来非常粗暴的back函数里面调用release来解决内存问题，另一种通过引入 TestProxy 把释放内存的时机放到了 AViewController 的 dealloc。一般情况建议大家这样引用TestProxy, 因为这样写法不需要考虑内存释放的时机的。同理NSTimer这种也可以引入Proxy，然后在 dealloc 调用 invalidate即可。
总结：循环引用计数的关键点在于 setDelegate方法， aaa.delegate = self; aaa.delegate = nil 。
