iOS容易形成循环引用的三种场景

ARC已经出来好久了，自动释放内存的确很方便，可是并不是绝对安全绝对不会产生内存泄露。致使iOS对象没法按预期释放的一个无形杀手是——循环引用。循环引用能够简单理解为A引用了B，而B又引用了A，双方都同时保持对方的一个引用，致使任什么时候候引用计数都不为0，始终没法释放。若当前对象是一个ViewController，则在dismiss或者pop以后其dealloc没法被调用，在频繁的push或者present以后内存暴增，而后APP就duang地挂了。下面列举咱们变成中比较容易碰到的三种循环引用的情形。

（1）计时器NSTimer

一方面，NSTimer常常会被做为某个类的成员变量，而NSTimer初始化时要指定self为target，容易形成循环引用。 另外一方面，若timer一直处于validate的状态，则其引用计数将始终大于0。先看一段NSTimer使用的例子(ARC模式)：

1 #import <Foundation/Foundation.h>
2 @interface Friend : NSObject
3 - (void)cleanTimer;
4 @end

 1 #import "Friend.h"
 2 @interface Friend ()
 3 {
 4     NSTimer *_timer;
 5 }
 6 @end
 7 
 8 @implementation Friend
 9 - (id)init
10 {
11     if (self = [super init]) {
12         _timer = [NSTimer scheduledTimerWithTimeInterval:1 target:self selector:@selector(handleTimer:)
13                                                 userInfo:nil repeats:YES];
14     }
15     return  self;
16 }
17 
18 - (void)handleTimer:(id)sender
19 {
20     NSLog(@"%@ say: Hi!", [self class]);
21 }
22 - (void)cleanTimer
23 {
24     [_timer invalidate];
25     _timer = nil;
26 }
27 - (void)dealloc
28 {
29     [self cleanTimer];
30     NSLog(@"[Friend class] is dealloced");
31 }

在类外部初始化一个Friend对象，并延迟5秒后将friend释放(外部运行在非arc环境下)

1         Friend *f = [[Friend alloc] init];
2         dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 5*NSEC_PER_SEC), dispatch_get_main_queue(), ^{
4             [f release];
5         });

咱们所期待的结果是，初始化5秒后，f对象被release，f的dealloc方法被调用，在dealloc里面timer失效，对象被析构。但结果倒是如此：

1 2 3 4 5 6 7 8 9 10

2015-03-18 18:00:35.300 WZLCodeLibrary[41422:3390529] Friend say: Hi! 2015-03-18 18:00:36.299 WZLCodeLibrary[41422:3390529] Friend say: Hi! 2015-03-18 18:00:37.300 WZLCodeLibrary[41422:3390529] Friend say: Hi! 2015-03-18 18:00:38.299 WZLCodeLibrary[41422:3390529] Friend say: Hi! 2015-03-18 18:00:39.299 WZLCodeLibrary[41422:3390529] Friend say: Hi! //运行了5次后没按照预想的停下来 2015-03-18 18:00:40.299 WZLCodeLibrary[41422:3390529] Friend say: Hi! 2015-03-18 18:00:41.300 WZLCodeLibrary[41422:3390529] Friend say: Hi! 2015-03-18 18:00:42.300 WZLCodeLibrary[41422:3390529] Friend say: Hi! 2015-03-18 18:00:43.299 WZLCodeLibrary[41422:3390529] Friend say: Hi! 2015-03-18 18:00:44.300 WZLCodeLibrary[41422:3390529] Friend say: Hi!<br>.......根本停不下来.....

这是为何呢？主要是由于从timer的角度，timer认为调用方(Friend对象)被析构时会进入dealloc，在dealloc能够顺便将timer的计时停掉而且释放内存；可是从Friend的角度，他认为timer不中止计时不析构，那我永远没机会进入dealloc。循环引用，互相等待，子子孙孙无穷尽也。问题的症结在于-(void)cleanTimer函数的调用时机不对，显然不能想固然地放在调用者的dealloc中。一个比较好的解决方法是开放这个函数，让Friend的调用者显式地调用来清理现场。以下：

1 2 3 4 5

Friend *f = [[Friend alloc] init]; dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 5* NSEC_PER_SEC ), dispatch_get_main_queue(), ^{      [f cleanTimer];      [f release]; });

=======================================

（2）block

block在copy时都会对block内部用到的对象进行强引用(ARC)或者retainCount增1(非ARC)。在ARC与非ARC环境下对block使用不当都会引发循环引用问题，通常表现为，某个类将block做为本身的属性变量，而后该类在block的方法体里面又使用了该类自己，简单说就是self.someBlock = ^(Type var){[self dosomething];或者self.otherVar = XXX;或者_otherVar = ...};block的这种循环引用会被编译器捕捉到并及时提醒。举例以下，依旧以Friend类为例子：

#import "Friend.h"

@interface Friend ()
@property (nonatomic) NSArray *arr;
@end

@implementation Friend
- (id)init
{
    if (self = [super init]) {
         self.arr = @[@111, @222, @333];
        self.block = ^(NSString *name){
            NSLog(@"arr:%@", self.arr);
        };
    }
    return  self;
}

咱们看到，在block的实现内部又使用了Friend类的arr属性，xcode给出了warning， 运行程序以后也证实了Friend对象没法被析构：

网上大部分帖子都表述为"block里面引用了self致使循环引用"，但事实真的是如此吗？我表示怀疑，其实这种说法是不严谨的，不必定要显式地出现"self"字眼才会引发循环引用。咱们改一下代码，不经过属性self.arr去访问arr变量，而是经过实例变量_arr去访问，以下：

由此咱们知道了，即便在你的block代码中没有显式地出现"self"，也会出现循环引用！只要你在block里用到了self所拥有的东西！但对于这种状况，目前我不知道该如何排除掉循环引用，由于咱们没法经过加__weak声明或者__block声明去禁止block对self进行强引用或者强制增长引用计数。对于self.arr的状况，咱们要分两种环境去解决：

1)ARC环境下：ARC环境下能够经过使用_weak声明一个代替self的新变量代替原先的self，咱们能够命名为weakSelf。经过这种方式告诉block，不要在block内部对self进行强制strong引用：(若是要兼容ios4.3，则用__unsafe_unretained代替__weak，不过目前基本不需考虑这么low的版本)

1          self.arr = @[@111, @222, @333];
2         __weak typeof(self) weakSelf=self;
3         self.block = ^(NSString *name){
4             NSLog(@"arr:%@", weakSelf.arr);
5         };

2)MRC环境下：解决方式与上述基本一致，只不过将__weak关键字换成__block便可，这样的意思是告诉block：小子，不要在内部对self进行retain了！

 

=========================================================

（3）委托delegate

在委托问题上出现循环引用问题已是老生常谈了，本文也再也不细讲，规避该问题的杀手锏也是简单到哭，一字诀：声明delegate时请用assign(MRC)或者weak(ARC)，千万别手贱玩一下retain或者strong，毕竟这基本逃不掉循环引用了！

转：http://www.cnblogs.com/wengzilin/p/4347974.html