iOS-ARC机制

来源:转载

内存管理是开发软件中重要的一个课题。如果内存管理不当,轻者内存泄露,重者程序崩溃。

下面重要讲述一下iOS的ARC(Automatic Reference Counting))机制。

ARC的历史由来

在iOS1.0的时候,苹果公司没有开放手机开发接口,不存在iOS开发者这个概念。

在iOS2.0的时候,我们管理内存使用的技术数MRC机制。

在iOS5.0的时候,苹果公司推出了ARC机制。

我们知道在MRC管理内存的时候,我们需要遵守“谁创建,谁释放,谁引用,谁管理”这个黄金法则,我们在创建对象的时候,需要考虑在什么时候释放内存,有时候对内存管理机制不熟悉的话,就很有可能导致内存泄露和过度释放的问题。

手动管理内存会导致很多问题的产生,在iOS5.0的时候,苹果推出了自动内存管理ARC,当时使用的IDE是XCode4.0,在我们创建工程的时候,下面有一个选项,是否使用ARC,给开发者一个自主选择,但是推出ARC,去很少人去使用ARC,在XCode5.0的时候,已经不存在这个选项,我们创建工程默认选择的是ARC机制,我们我们想要使用MRC,需要手动配置工程。

在推出ARC的时候,很多人都说iOS的ARC和Android的GC机制很像,但是他们本身还是有很大的区别的。其中GCS是运行时特性,ARC是编译时特性。

ARC的使用

ARC我们字面翻译是自动引用计数,引申意我们可以理解为自动内存管理。自动内存管理难道我们真的不需要管理了吗?非也。ARC机制也会导致内存泄露的问题,我们在使用的时候,需要注意这些问题。

我们在MRC中,我们经常要使用release,autorelease,retain这些关键字,来保留引用计数或者释放对象。在ARC中,我们就不能这么处理了。如果我们使用这些关键字,我们的程序在基本的编译都不能通过。

既然我们创建的对象,不用我们手动释放,系统在必要的时候会为我们释放,那么对象会在什么时候释放掉呢?

探讨这个问题之前,我们先说明一下使用ARC的基本准则。

  • 强引用指向的对象不会被释放。
  • 一个对象没有强引用会立刻释放。
  • 弱引用指向的对象将要释放时自动为空。

注意:我们创建的对象默认是强引用,比如:People = [People new];等价__strong People = [People new];

下面我们讲述的内容都围绕着这三个准则。

一、局部对象

首先创建一个工程,然后添加一个类People,下面为People的.m文件内容。

 

 1 @implementation People 2 -(id)init 3 { 4 if (self = [super init]) 5 { 6 NSLog(@"%s",__FUNCTION__); 7 } 8 return self; 9 }10 -(void)dealloc11 {12 NSLog(@"%s",__FUNCTION__);13 }14 @end
People.m

 

我们在viewDidLoad中添加People *p = [People new]; NSLog(@"%s",__FUNCTION__);

打印结果为:

2015-10-19 13:16:10.589 textarc[2627:93432] -[People init]2015-10-19 13:16:10.600 textarc[2627:93432] -[ViewController viewDidLoad]
2015-10-19 13:16:10.600 textarc[2627:93432] -[People dealloc]

我们发现People这个对象别释放,从打印顺序上我们可以看到是在viewDidLoad执行完毕之后这个People对象被释放掉的。

局部对象为什么会在函数执行完毕之后被释放掉呢?

在viewDidLoad中,p是一个强引用,对象不会被释放,会打印NSLog中的内容。但是在函数执行完毕之后,强引用指针不在指向对象。根据上面的准则,没有强指针指向对象会被立刻释放,所以在执行完viewDidLoad之后,对象People会被释放掉。

如果我们在viewDidLoad中这样写:

__weak People *p = [People new];
NSLog(@"%s",__FUNCTION__);

我们可以猜测到打印结果就会跟上面的不同

2015-10-19 13:22:10.783 textarc[2682:96983] -[People init]
2015-10-19 13:22:10.783 textarc[2682:96983] -[People dealloc]
2015-10-19 13:22:10.784 textarc[2682:96983] -[ViewController viewDidLoad]

因为对象没有强指针引用,所以People会被释放,然后执行下面的打印。

二、全局变量

现在我们将People定义成全局对象,命名为_people。

我们在viewDidLoad中写下面代码:

 _people = [People new];
 NSLog(@"%s",__FUNCTION__);

打印结果为:

2015-10-19 13:28:32.076 textarc[2764:100790] -[People init]
2015-10-19 13:28:32.077 textarc[2764:100790] -[ViewController viewDidLoad]

我们发现并没有调用People的dealloc方法,因为在执行完viewDid这个函数时,还有一个强引用指针指向People,根据上面的准则,对象不会被释放。

如果我们在全局对象前面加上一个__weak:   __weak People *_people;

再执行上面的代码,打印结果为:

2015-10-19 13:31:47.816 textarc[2803:102843] -[People init]
2015-10-19 13:31:47.827 textarc[2803:102843] -[People dealloc]
2015-10-19 13:31:47.828 textarc[2803:102843] -[ViewController viewDidLoad]

出现这个结果不用解释了吧,虽然是一个全局的对象,但是是弱引用,没有强引用,对象会被释放掉。

 

三、全局和局部混合使用

现在我们定义一个全局行强指针People的对象p,同时创建一个局部性强指针对象p1.

viewDidLoad中为:

People *p1 = [People new];
p = p1;

执行结果为:

2015-10-19 13:49:32.380 textarc[3088:111876] -[People init]
2015-10-19 13:49:32.383 textarc[3088:111876] -[ViewController viewDidLoad]

因为p1是局部强引用,在函数执行完后按常理是被释放掉,但是在释放前,有一个全局性的强引用执行了它,所有People没有被释放掉。

如果我们在viewDid中这样写:

__weak People *p1 = [People new];
p = p1;

NSLog(@"%s",__FUNCTION__);

打印结果为:

2015-10-19 13:50:43.647 textarc[3115:112734] -[People init]
2015-10-19 13:50:43.651 textarc[3115:112734] -[People dealloc]
2015-10-19 13:50:43.651 textarc[3115:112734] -[ViewController viewDidLoad]

因为局部对象是弱引用,对象会被释放掉,在赋值给全局强引用之前,它已经为空了,对象已经释放掉了。

四、创建对个对象嵌套

假设我们还有一个类,类名为Car,People有一个属性,@property(nonatomic,strong) Car *car;

现在我们把People声明一个全局对象p.

在viewDidLoad中:

p = [People new];
Car *c = [Car new];
p.car = c;
NSLog(@"%s",__FUNCTION__);

打印结果:

2015-10-19 13:57:21.883 textarc[3220:116572] -[People init]
2015-10-19 13:57:21.886 textarc[3220:116572] -[Car init]
2015-10-19 13:57:21.886 textarc[3220:116572] -[ViewController viewDidLoad]

Car虽然是局部引用,但是函数执行完毕后没有释放,因为p对其还有一个强引用,所有Car不会被释放掉。

如果我们将People释放掉,Car自然也会释放。

我们想要释放一个一个变量的话,我们可以直接将变量赋值为空,就会释放掉。

例如:

p = [People new];
Car *c = [Car new];
p.car = c;
p = nil;
NSLog(@"%s",__FUNCTION__);

打印结果为:

2015-10-19 14:01:14.703 textarc[3265:118993] -[People init]
2015-10-19 14:01:14.706 textarc[3265:118993] -[Car init]
2015-10-19 14:01:14.706 textarc[3265:118993] -[People dealloc]
2015-10-19 14:01:14.706 textarc[3265:118993] -[ViewController viewDidLoad]
2015-10-19 14:01:14.707 textarc[3265:118993] -[Car dealloc]

五、循环引用问题

加入在People中有Car这个属性,在Car中有People这个属性。(注意交叉引用问题)

我们在viewDidLoad中:

People * p = [People new];
Car *c = [Car new];
p.car = c;
c.people = p;
NSLog(@"%s",__FUNCTION__);

结果为:

2015-10-19 14:05:50.296 textarc[3320:121202] -[People init]
2015-10-19 14:05:50.298 textarc[3320:121202] -[Car init]
2015-10-19 14:05:50.298 textarc[3320:121202] -[ViewController viewDidLoad]

我们发现都没有释放,会导致内存泄露。当然我们可以将c,或者p赋值为nil将其释放掉。但是这样写很糟糕,我们需要判断什么释放决定释放。

如何解决这个问题呢?

在属性修饰的时候,不要同时使用strong,可以一个使用weak修饰,则运行结果如下:

2015-10-19 15:45:53.289 textarc[3937:150043] -[People init]
2015-10-19 15:45:53.298 textarc[3937:150043] -[Car init]
2015-10-19 15:45:53.298 textarc[3937:150043] -[ViewController viewDidLoad]
2015-10-19 15:45:53.298 textarc[3937:150043] -[People dealloc]
2015-10-19 15:45:53.298 textarc[3937:150043] -[Car dealloc]

 

 ARC总结在使用ARC的时候,可以在一定程度上简化我们的编程操作,但是在使用的过程中也会出现内存泄露的问题,需要我们在实际使用过程中总结出现问题的情况,让我们的程序有更少的bug和潜在的bug。     



分享给朋友:
您可能感兴趣的文章:
随机阅读: