ARC是什么东东？retain和release到底怎么玩？(★firecat推荐★)

文章来源：http://blog.csdn.net/chaoyuan899/article/details/10327157

http://www.yifeiyang.net/development-of-the-iphone-simply-1/

内存管理

    范围：

• 任何继承了NSObject 的对象，对基本数据类型无效

   原理：

• 每个对象内部都保存了一个与之相关联的整数，称为引用计数器（auto reference count）
• 每当使用 alloc、new或者copy创建一个对象时，对象的引用计数器被设置为1
• 给对象发送一条retain消息（即调用retain方法），可以使引用计数器值+1
• 给对象发送一条release消息，可以使引用计数器值-1
• 当一个对象的引用计数器值为0时，那么它将被销毁，其占用的内存被系统回收，OC也会自动向对象发送一条dealloc消息。一般会重写dealloc方法，在这里释放相关资源。一定不要直接调用dealloc方法。
• 可以给对象发送retainCount消息获得当前的引用计数器值。

内存管理原则

1. 谁创建，谁释放（“谁污染，谁治理”）。如果你通过alloc、new或者(mutable)copy来创建一个对象，那么你必须调用release或autorelease。或句话说，不是你创建的，就不用你去释放
2. 一般来说，除了alloc、new或copy之外的方法创建的对象都被声明了autorelease（autorelease是延迟释放内存，不用你自己去手动释放，系统会知道在什么时候该去释放掉它。）
3. 谁retain，谁release。只要你调用了retain，无论这个对象是如何生成的，你都要调用release

下面是测试代码：

新建一个基于“Command Line Tool”的工程，名为“内存管理1-retain和release的简单使用”，再新建一个Student类。

Student.h

[cpp]  view plain copy print ?

1. //  
2. //  Student.h  
3. //  内存管理1-retain和release的简单使用  
4. //  
5. //  Created by Rio.King on 13-8-26.  
6. //  Copyright (c) 2013年 Rio.King. All rights reserved.  
7. //  
8.   
9. #import <Foundation/Foundation.h>  
10.   
11. @interface Student : NSObject  
12. {  
13.     int age;  
14. }  
15.   
16. @property int age;  
17.   
18. @end  

Student.m

[cpp]  view plain copy print ?

1. //  
2. //  Student.m  
3. //  内存管理1-retain和release的简单使用  
4. //  
5. //  Created by Rio.King on 13-8-26.  
6. //  Copyright (c) 2013年 Rio.King. All rights reserved.  
7. //  
8.   
9. #import "Student.h"  
10.   
11. @implementation Student  
12.   
13. @synthesize age;  
14.   
15. //重写dealloc方法，当引用计数器（auto reference count）为零的时候调用，注意，没有在.h头文件中声明的方法都属于私有方法。  
16. - (void)dealloc{  
17.       
18.     //insert your code here...  
19.     NSLog(@"%@被销毁了",self);  
20.       
21.     [super dealloc];//一定要调用super的dealloc方法，而且最好放在最后面实现  
22. }  
23.   
24. @end  

main.m

[cpp]  view plain copy print ?

1. //  
2. //  main.m  
3. //  内存管理1-retain和release的简单使用  
4. //  
5. //  Created by Rio.King on 13-8-26.  
6. //  Copyright (c) 2013年 Rio.King. All rights reserved.  
7. //  
8.   
9. #import <Foundation/Foundation.h>  
10. #import "Student.h"  
11.   
12. int main(int argc, const char * argv[])  
13. {  
14.   
15.     @autoreleasepool {  
16.           
17.         Student *stu = [[Student alloc]init];//alloc一次，引用计数器为1  
18.         //Student *stu = [[[Studnet alloc]init] autorelease]; //这样写的话系统会在适当的地方对stu的内存进行自动回收，就不用自己写release回收了  
19.           
20.         //z代表无符号  
21.         NSLog(@"count:%zi", [stu retainCount]);  
22.           
23.         [stu retain];//引用计数器变为2  
24.         NSLog(@"count:%zi", [stu retainCount]);  
25.           
26.         [stu release];//引用计数器变为1  
27.         NSLog(@"count:%zi", [stu retainCount]);          
28.           
29.         [stu release];//release一次，引用计数器减1，变为0,,,然后会调用dealloc方法  
30.           
31.     }  
32.     return 0;  
33. }  

运行结果：

2013-08-26 10:53:14.506内存管理1-retain和release的简单使用[754:303] count:1

2013-08-26 10:53:14.508内存管理1-retain和release的简单使用[754:303] count:2

2013-08-26 10:53:14.509内存管理1-retain和release的简单使用[754:303] count:1

2013-08-26 10:53:14.509内存管理1-retain和release的简单使用[754:303] <Student: 0x100109a80>被销毁了

ARC是什么

ARC是iOS 5推出的新功能，全称叫 ARC(Automatic Reference Counting)。简单地说，就是代码中自动加入了retain/release，原先需要手动添加的用来处理内存管理的引用计数的代码可以自动地由编译器完成了。

该机能在 iOS 5/ Mac OS X 10.7 开始导入，利用 Xcode4.2 可以使用该机能。简单地理解ARC，就是通过指定的语法，让编译器(LLVM 3.0)在编译代码时，自动生成实例的引用计数管理部分代码。有一点，ARC并不是GC，它只是一种代码静态分析（Static Analyzer）工具。

 

变化点

通过一小段代码，我们看看使用ARC前后的变化点。

 

C代码  

1. @interface NonARCObject : NSObject {    
2.     NSString *name;    
3. }    
4. -(id)initWithName:(NSString *)name;    
5. @end    
6.    
7. @implementation NonARCObject    
8. -(id)initWithName:(NSString *)newName {    
9.     self = [super init];    
10.     if (self) {    
11.         name = [newName retain];    
12.     }    
13.     return self;    
14. }    
15.    
16. -(void)dealloc {    
17.     [name release];    
18.     [Super dealloc];    
19. }    
20. @end    

 

 

C代码  

1. @interface ARCObject : NSObject {    
2.     NSString *name;    
3. }    
4. -(id)initWithName:(NSString *)name;    
5. @end    
6.    
7. @implementation ARCObject    
8. -(id)initWithName:(NSString *)newName {    
9.     self = [super init];    
10.     if (self) {    
11.         name = newName;    
12.     }    
13.     return self;    
14. }    
15. @end    

 

 

我们之前使用Objective-C中内存管理规则时，往往采用下面的准则

•    生成对象时，使用autorelease
•    对象代入时，先autorelease后再retain
•    对象在函数中返回时，使用return [[object retain] autorelease];

而使用ARC后，我们可以不需要这样做了，甚至连最基础的release都不需要了。

 

使用ARC的好处

使用ARC有什么好处呢？

•    看到上面的例子，大家就知道了，以后写Objective-C的代码变得简单多了，因为我们不需要担心烦人的内存管理，担心内存泄露了
•    代码的总量变少了，看上去清爽了不少，也节省了劳动力
•    代码高速化，由于使用编译器管理引用计数，减少了低效代码的可能性

 

不好的地方

•    记住一堆新的ARC规则 — 关键字及特性等需要一定的学习周期
•    一些旧的代码，第三方代码使用的时候比较麻烦；修改代码需要工数，要么修改编译开关

关于第二点，由于 XCode4.2 中缺省ARC就是 ON 的状态，所以编译旧代码的时候往往有"Automatic Reference Counting Issue"的错误信息。

 

这个时候，可以将项目编译设置中的“Objectice-C Auto Reference Counteting”设为NO。如下所示。

 

如果只想对某个.m文件不适应ARC，可以只针对该类文件加上 -fno-objc-arc 编译FLAGS，如下图。

 

 

ARC基本规则

•     retain, release, autorelease, dealloc由编译器自动插入，不能在代码中调用
•     dealloc虽然可以被重载，但是不能调用[super dealloc]

由于ARC并不是GC，并需要一些规则让编译器支持代码插入，所以必须清楚清楚了这些规则后，才能写出健壮的代码。

 

Objective-C对象

ObjectiveC中的对象，有强参照(Strong reference)和弱参照(Weak reference)之分，当需要保持其他对象的时候，需要retain以确保对象引用计数加1。对象的持有者(owner)只要存在，那么该对象的强参照就一直存在。

对象处理的基本规则是

•     只要对象的持有者存在（对象被强参照），那么就可以使用该对象
•     对象失去了持有者后，即被破弃

 

强参照 (Strong reference)

 

(s1)

firstName作为”natsu”字符串对象的最初持有者，是该NSString类型对象的Strong reference。

(s2)

这里将firstName代入到aName中，即aName也成为了@”natsu”字符串对象的持有者，对于该对象，aName也是Strong reference。

(s3)

这里，改变firstName的内容。生成新的字符串对象”maki”。这时候firstName成为”maki”的持有者，而@”natsu”的持有者只有aName。每个字符串对象都有各自的持有者，所以它们都在内存中都存在。

(s4)

追加新的变量otherName, 它将成为@”maki”对象的另一个持有者。即NSString类型对象的Strong reference。

(s5)

将otherName代入到aName，这时，aName将成为@”maki”字符串对象的持有者。而对象@”natsu”已经没有持有者了，该对象将被破弃。

 

弱参照 (Weak reference)

接下来我们来看看弱参照 (Weak reference) 的使用方式。

 

 

(w1)

与强参照方式同样，firstName作为字符串对象@”natsu”的持有者存在。即是该NSString类型对象的Strong reference。

(w2)

使用关键字__weak，声明弱参照weakName变量，将firstName代入。这时weakName虽然参照@”natsu”，但仍是Weak reference。即weakName虽然能看到@”natsu”，但不是其持有者。

(w3)

firstName指向了新的对象@”maki”，成为其持有者，而对象@”natsu”因为没有了持有者，即被破弃。同时weakName变量将被自动代入nil。

 

引用关键字

ARC中关于对象的引用参照，主要有下面几关键字。使用strong, weak, autoreleasing限定的变量会被隐式初始化为nil。

 

• __strong

变量声明缺省都带有__strong关键字，如果变量什么关键字都不写，那么缺省就是强参照。

 

• __weak

上面已经看到了，这是弱参照的关键字。该概念是新特性，从 iOS 5/ Mac OS X 10.7 开始导入。由于该类型不影响对象的生命周期，所以如果对象之前就没有持有者，那么会出现刚创建就被破弃的问题，比如下面的代码。

 

C代码  

1. NSString __weak *string = [[NSString alloc] initWithFormat:@"First Name: %@", [self firstName]];    
2. NSLog(@"string: %@", string); //此时 string为空   

 

如果编译设定OS版本 Deployment Target 设定为这比这低的版本，那么编译时将报错(The current deployment target does not support automated __weak references)，这个时候，我们可以使用下面的 __unsafe_unretained。

弱参照还有一个特征，即当参数对象失去所有者之后，变量会被自动付上nil (Zeroing)。

 

• __unsafe_unretained

该关键字与__weak一样，也是弱参照，与__weak的区别只是是否执行nil赋值(Zeroing)。但是这样，需要注意变量所指的对象已经被破弃了，地址还还存在，但内存中对象已经没有了。如果还是访问该对象，将引起「BAD_ACCESS」错误。

 

• __autoreleasing

该关键字使对像延迟释放。比如你想传一个未初始化的对像引用到一个方法当中，在此方法中实例化此对像，那么这种情况可以使用__autoreleasing。他被经常用于函数有值参数返回时的处理，比如下面的例子。

  

C代码  

1. - (void) generateErrorInVariable:(__autoreleasing NSError **)paramError {    
2.     ....    
3.     *paramError = [[NSError alloc] initWithDomain:@"MyApp" code:1 userInfo:errorDictionary];    
4. }    
5.    
6. ....    
7. {    
8.     NSError *error = nil;    
9.     [self generateErrorInVariable:&error];    
10.     NSLog(@"Error = %@", error);    
11. }    

 

又如函数的返回值是在函数中申请的，那么希望释放是在调用端时，往往有下面的代码。

 

C代码  

1. -(NSString *)stringTest    
2. {    
3.     NSString *retStr = [NSString stringWithString:@"test"];    
4.    
5.     return [[retStr retain] autorelease];    
6. }    
7.    
8. // 使用ARC    
9.    
10. -(NSString *)stringTest    
11. {    
12.     __autoreleasing NSString *retStr = [NSString alloc] initWithString:@"test"];    
13.    
14.     return retStr;    
15. }    

 

 

即当方法的参数是id*，且希望方法返回时对象被autoreleased，那么使用该关键字。

 

总结

今天，我们看到了 基本的ARC使用规则

•     代码中不能使用retain, release, retain, autorelease
•     不重载dealloc（如果是释放对象内存以外的处理，是可以重载该函数的，但是不能调用[super dealloc]）
•     不能使用NSAllocateObject, NSDeallocateObject
•     不能在C结构体中使用对象指针，除非使用__unsafe_unretained关键字
•     id与void *间的如果cast时需要用特定的方法（__bridge关键字）
•     不能使用NSAutoReleasePool、而需要@autoreleasepool块
•     不能使用“new”开始的属性名称 （如果使用会有下面的编译错误”Property’s synthesized getter follows Cocoa naming convention for returning ‘owned’ objects”）

详情可以参考书籍《 Objective-C高级编程：iOS与OS X多线程和内存管理》第50页。