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

下面重要讲述一下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)dealloc
11 {
12     NSLog(@"%s",__FUNCTION__);
13 }
14 @end

我们在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]