概述

在iOS中开发中，我们或多或少都听说过内存管理。iOS的内存管理一般指的是OC对象的内存管理，因为OC对象分配在堆内存，堆内存需要程序员自己去动态分配和回收；基础数据类型(非OC对象)则分配在栈内存中，超过作用域就会由系统检测回收。如果我们在开发过程中，对内存管理得不到位，就有可能造成内存泄露。

我们通常讲的内存管理，实际上从发展的角度来说，分为两个阶段：MRC和ARC。MRC指的是手动内存管理，在开发过程中需要开发者手动去编写内存管理的代码；ARC指的是自动内存管理，在此内存管理模式下由LLVM编译器和OC运行时库生成相应内存管理的代码。

通篇主要介绍关于内存管理的原理及ARC和MRC环境下编写代码实现的差异。

提纲

一引用计数

二 MRC操作对象的方法

alloc/new/copy/mutableCopy
retain
release
autorelease
autorelease pool

三 ARC操作对象的修饰符

__strong
1.1 strong与变量
1.2 strong与属性
1.3 strong的实现
__weak
2.1 weak和循环引用
2.2 weak和变量
2.3 weak的实现
2.3.1 weak和赋值
2.3.2 weak和访问
__unsafe_unretained
_autoreleasing

具体介绍

一、引用计数

在OC中，使用引用计数来进行内存管理。每个对象都有一个与其相对应的引用计数器，当持有一个对象，这个对象的引用计数就会递增；当这个对象的某个持有被释放，这个对象的引用计数就会递减。当这个对象的引用计数变为0，那么这个对象就会被系统回收。

当一个对象使用完没有释放，此时其引用计数永远大于1。该对象就会一直占用其分配在堆内存的空间，就会导致内存泄露。内存泄露到一定程度有可能导致内存溢出，进而导致程序崩溃。

二、MRC操作对象的方法

1.alloc/new/copy/mutableCopy

1.1 持有调用者自己的对象

在苹果规定中，使用alloc/new/copy/mutableCopy创建返回的对象归调用者所有，例如以下MRC代码：

    NSMutableArray *array = [[NSMutableArray alloc] init];/*NSMutableArray类对象A*/
    
    NSLog(@"%p", array);
    
    [array release];//释放

由于对象A由alloc生成，符合苹果规定，指针变量array指向并持有对象A，引用计数器会加1。另外，array在使用完对象A后需要对其进行释放。当调用release后，释放了其对对象A的引用，计数器减1。对象A此时引用计数值为零，所以对象A被回收。不能访问已经被回收的对象，会发生崩溃。

1.2 持有非调用者拥有的对象

当持有非调用者自己拥有的对象的时候，例如以下代码：

    id obj = [Person person];
    
    [obj retain];
    
    /*do something*/
    
    [obj release];

此时obj变量获得但不持有Person类对象，可以通过retain进行持有该对象。当我们使用完该对象，应该调用release方法释放该对象。

注意：按照苹果的命名规则，必须是alloc/new/copy/mutableCopy开头，并且是符合驼峰命名规则生成的对象才归调用者所有。例如以下的方法，生成的对象不归调用者所有：

- (id)newarray;
- (id)allocwithInfo;
- (id)coPySomething;
- (id)mutablecopyItem;

2.retain

2.1 retain和属性

我们可以通过属性来保存对象，如果一个属性为强引用，我们就可以通过属性的实例变量和存取方法来对某个对象进行操作，例如某个属性的setter方法如下：

- (void)setPerson:(Person *)person {

    [person retain];
    
    [_person release];
    
    _person = person;
    
}

我们通过retain新值，release旧值，再给实例变量更新值。需要注意的一点是：需要先retain新值，再release新值。因为如果新旧值是同一个对象的话，先release就有可能导致该对象被系统回收，再去retain就没有任何意义了。例如下面这个例子：

#import "ViewController.h"
#import "Person.h"

@interface ViewController ()

@property (nonatomic, strong)Person *person;

@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
  
    //实例变量持有Person类对象(P对象)。这样赋值不会调用set方法
    _person = [[Person alloc] init];
    
    self.person = _person;//调用set方法
    
}

- (void)setPerson:(Person *)person {
    //release释放对P对象的引用，P对象引用计数值变为零，则P对象被系统回收
    [_person release];

    //由于P对象已经被回收，再去retain就容易出问题
    [person retain];
    
    _person = person;
    
}

@end

由于P对象被回收，对应其所分配的内存被置于“可用内存池”中。如果该内存未被覆写，那么P对象依然有效；如果内存被覆写，那么实例变量_person就会指向一个被覆写的未知对象的指针，那么实例变量就变成一个“悬挂指针”。

2.2 retain和数组

如果我们把一个对象加入到一个数组中，那么该数组的addObject方法会对该对象调用retain方法。例如以下代码：

    //person获得并持有P对象，P对象引用计数为1
    Person *person = [[Person alloc] init];//Person类对象生成的P对象
    
    NSMutableArray *array = [NSMutableArray array];
    
    //person被加入到数组，对象P引用计数值为2
    [array addObject:person];

此时，对象P被person和array两个变量同时持有。

3.release

3.1 自己持有的对象自己释放

当我们持有一个对象，如果在不需要继续使用该对象，我们需要对其进行释放(release)。例如以下代码：

    //array获得并持有NSArray类对象
    NSArray *array = [[NSArray alloc] init];
    
    /*当不再需要使用该对象时，需要释放*/
    [array release];
    
    //obj获得但不持有该对象
    id obj = [NSArray array];

    //持有对象
    [obj retain];    

    /*当不在需要使用该对象时，需要释放*/
    [obj release];

3.2 非自己持有的对象不要释放

当我们不持有某个对象，却对该对象进行释放，应用程序就会崩溃。

    //获得并持有A对象
    Person *p = [[Person alloc] init];//Person类对象A
    
    //p释放对象A的强引用，对象A所有者不存在
    //对象A引用计数为零，所以对象A被回收
    [p release];

    [p release];//释放非自己持有的对象

另外，我们也不能访问某个已经被释放的对象，该对象所占的堆空间如果被覆写就会发生崩溃的情况。

4.autorelease

autorelease指的是自动释放，当一个对象收到autorelease的时候，该对象就会被注册到当前处于栈顶的自动释放池（autorelease pool）。如果没有主动生成自动释放池，则当前自动释放池对应的是主运行循环的自动释放池。在当前线程的RunLoop进入休眠前，就会对被注册到该自动释放池的所有对象进行一次release操作。

autorelease和release的区别是：release是马上释放对某个对象的强引用；autorelease是延迟释放某个对象的生命周期。

autorelease通常运用在当调用某个方法需要返回对象的情况下，例如以下代码：

    //外部调用
    Person *p = [Person person];
    NSLog(@"%p", p);//使用无须retain

    //持有则需要retain
    [p retain];
    _person = p;
    [_person release];

    //Person类内部定义
+ (id)person {

    //创建的Person类对象由person获得并持有
    Person *person = [[Person alloc] init];
   
    //[person release];

    [person autorelease];
    
    return person;
}

在外部调用，从方法名person知道，创建的对象由p指针变量获得但不持有。在函数内部，person获得并持有了Person类对象，所返回的person对象的引用计数加1。换句话说，调用者需要额外处理这多出来的一个持有操作。另外，我们不能在函数内部调用release，不然对象还没返回就已经被系统回收。这时候使用autorelease就能很好地解决这个问题。

只要把要返回的对象调用autorelease方法，注册到自动释放池就能延长person对象的生命周期，使其在autorelease pool销毁(drain)前依然能够存活。

另外，person对象在返回时调用了autorelease方法。该对象已经在自动释放池中，我们可以直接使用对象p，无须再通过[p retain]访问;不过，如果要用实例变量持有该对象，则需要对变量p进行一次retain操作，示例变量使用完该对象需要释放该对象。

5. autorelease pool

5.1 autorelease pool和RunLoop(运行循环)

每条线程都包含一个与其对应的自动释放池，当某条线程被终止的时候，对应该线程的自动释放池会被销毁。同时，处于该自动释放池的对象将会进行一次release操作。

当应用程序启动，系统默认会开启一条线程，该线程就是“主线程”。主线程也有一个与之对应的自动释放池，例如我们常见的ARC下的main.h文件：

int main(int argc, char * argv[]) {
    @autoreleasepool {
        return UIApplicationMain(argc, argv, nil, NSStringFromClass([AppDelegate class]));
    }
}

该自动释放池用来释放在主线程下注册到该自动释放池的对象。需要注意的是，当我们开启一条子线程，并且在该线程开启RunLoop的时候，需要为其增加一个autorelease pool，这样有助于保证内存的安全。

5.2 autorelease pool和降低内存峰值

当我们执行一些复杂的操作，特别是如果这些复杂的操作要被循环执行，那么中间会免不了会产生一些临时变量。当被加到主线程自动释放池的对象越来越来多，却没有得到及时释放，就会导致内存溢出。这个时候，我们可以手动添加自动释放池来解决这个问题。如以下例子所示：

for (int i = 0; i < largeNumber; i++) {
        
        //创建自动释放池
        NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
        
        //产生许多被注册到自动释放池的临时对象
        id obj = [Person personWithComplexOperation];
        
        //释放池中对象
        [pool drain];
        
    }

如上述例子所示，我们执行的循环次数是一个非常大的数字。并且调用personWithComplexOperation方法的过程中会产生许多临时对象，所产生的临时对象有可能会被注册到自动释放池中。我们通过手动生成一个自动释放池，并且在每次循环结束前把该自动释放池的对象执行release操作释放掉，这样就能有效地降低内存的峰值了。

三 ARC操作对象的修饰符

1. __strong

1.1 __strong与变量

在ARC模式下，id类型和OC对象的所有权修饰符默认是__strong。当一个变量通过__strong修饰符来修饰，当该变量超出其所在作用域后，该变量就会被废弃。同时，赋值给该变量的对象也会被释放。例如：

{
    //变量p持有Person对象的强引用
    Person *p = [Person person];
    
    //__strong修饰符可以省略
    //Person __strong *p = [Person person];
}
    //变量p超出作用域，释放对Person类对象的强引用
    //Person类对象持有者不存在，该对象被释放

上述例子对应的MRC代码如下：

{
    Person *p = [Person person];
    
    [p retain];
    
    [p release];
}

可以看出，ARC和MRC是对应的。只不过在ARC下，对象“持有”和“释放”的内存管理代码交由系统去调用罢了。

1.2 strong与属性

如果一个属性的修饰符是strong,对于其实例变量所持有的对象，编译器会在该实例变量所属类的dealloc方法为其添加释放对象的方法。在MRC下，我们的dealloc方法有如：

- (void)dealloc {

    [p release];//ARC无效
    
    [super dealloc];//ARC无效
}

在ARC下，我们就无须再去写这样的代码了。另外，在dealloc方法中，ARC只能帮我们处理OC对象。如果实例变量持有类似CoreFoundation等非OC对象，则需要我们手动回收：

- (void)dealloc {

    CFRelease(_cfObject);
}

在ARC下，dealloc方法一般用来执行两个任务。第一个就是手动释放非OC对象；第二个是接触监听。另外，在ARC下我们不能主动调用dealloc方法。因为一旦调用dealloc，对象就不再有效。该方法运行期系统会在合适的时机自动去调用。

1.3 strong的实现

在ARC中，除了会自动调用“保留”和“释放”方法外，还进行了优化。例如某个对象执行了多次“保留”和“释放”，那么ARC针对特殊情况有可能会将该对象的“保留”和“释放”成对地移除。例如：

+ (id)person {

    Person *tmp = [[Person alloc] init];//引用计数为1
    [tmp autorelease];//注册到自动释放池(ARC无效)
    return tmp;
}

{
    //ARC
    _p = [Person person];//_p是强引用属性对应的实例变量
    
    //实现展示
    Person *p = [Person person];//Person类对象引用计数为1
    _p = [p retain];//递增为2
    [_p release];//递减为1
}
    //清空自动释放池，Person类对象递减为0，释放该对象

在上述代码中，ARC对应MRC的具体实现展示。在上面的展示中，+(id)person方法内部会调用一次autorelease操作来延迟其返回对象的生命周期，并且稍后在自动释放池进行release操作。_p通过retain来持有该对象，使用完就执行release操作。从而看出retain和autorelease是多余的，完全可以简化成以下代码：

+ (id)person {

    Person *tmp = [[Person alloc] init];//引用计数为1
    return tmp;
}

{
    //ARC
    _p = [Person person];//_p是强引用属性对应的实例变量
    
    //实现展示
    _p = [Person person];//Person类对象引用计数为1
    [_p release];//递减为0，Person类对象被回收
}

那么ARC是如何判断是否移除这种成对的操作呢？其实在ARC中，并不是直接执行retain和autorelease操作的，而是通过以下两个方法：

    objc_autoreleaseReturnValue(obj);//对应autorelease
    objc_retainAutoreleasedReturnValue(obj);//对应retain

以下为两个方法对应的伪代码：

id objc_autoreleaseReturnValue(id obj) {

    if ("返回对象obj后面的那段代码是否执行retain") {
        //是
        set_flag(obj);//设置标志位
        return obj;
    } else {
        return [obj autorelease];
    }
}

id objc_retainAutoreleasedReturnValue(obj) {

    if (get_flag(obj)) {
        //有标志位
        return obj;
    } else {
        return [obj retain];
    }
}

通过以上两段伪代码，我们重新梳理一下代码：

+ (id)person {

    Person *tmp = [[Person alloc] init];//引用计数为1
    
    return objc_autoreleaseReturnValue(id tmp);
}

{
    //ARC
    _p = [Person person];//_p是强引用属性对应的实例变量
    
    //实现展示
    Person *p = [Person person];//Person类对象引用计数为1
    _p = objc_retainAutoreleasedReturnValue(p);//递增为1
    [_p release];//递减为0
}

从上述示例代码可以看出：

当我们用变量p获取person方法返回的对象前，person方法内部会执行objc_autoreleaseReturnValue方法。该方法会检测返回对象之后即将执行的那段代码，如果那段代码要向所返回的对象执行retain方法，则为该对象设置一个全局数据结构中的标志位，并把对象直接返回。反之，在返回之前把该对象注册到自动释放池。
当我们对Person类对象执行retain操作的时候，会执行objc_retainAutoreleasedReturnValue方法。该方法会检测对应的对象是否已经设置过标志位，如果是，则直接把该对象返回；反之，会向该对象执行一次retain操作再返回。

在ARC中，通过设置和检测标志位可以移除多余的成对(“保留”&“释放”)操作，优化程序的性能。

2. __weak

2.1 weak和循环引用

__weak与我们上述所提到的__strong相对应，__strong对某个对象具有强引用。那么，__weak则指的是对某个对象具有弱引用。一般weak用来解决我们开发中遇到的循环引用问题，例如以下代码：

/*Man类*/
#import <Foundation/Foundation.h>

@class Woman;

@interface Man : NSObject

@property (nonatomic, strong)Woman *person;

@end

/*Woman类*/
#import <Foundation/Foundation.h>

@class Man;

@interface Woman : NSObject

@property (nonatomic, strong)Man *person;

@end

/*调用*/
- (void)viewDidLoad {
    [super viewDidLoad];

    Man *man = [[Man alloc] init];
    
    Woman *woman = [[Woman alloc] init];
    
    man.person = woman;
    woman.person = man;
}

从上述代码可以看出，Man类对象和Woman类对象分别有一个所有权修饰符为strong的person属性。两个类之间互相通过实例变量进行强引用，Man类对象如果要释放，则需要Woman类对象向其发送release消息。然而Woman类对象要执行dealloc方法向Man类对象发送release消息的话，又需要Man类对象向其发送release消息。双方实例变量互相强引用类对象，所以造成循环引用，如下图所示：

循环引用.png

这时候weak修饰符就派上用场了，因为weak只通过弱引用来引用某个对象，并不会真正意义上的持有该对象。所以我们只需要把上述两个类对象的其中一个属性用weak来修饰，就可以解决循环引用的问题。例如我们把Woman类的person属性用weak来修饰，分析代码如下：

/*调用*/
- (void)viewDidLoad {
    [super viewDidLoad];

    Man *man = [[Man alloc] init];//Man对象引用计数为1
    
    Woman *woman = [[Woman alloc] init];//Woman对象引用计数为1
    
    man.person = woman;//强引用，Woman对象引用计数为2

    woman.person = man;//弱引用，Man对象引用计数为1
}
    //变量man超出作用域，对Man类对象的强引用失效
    //Man类对象持有者不存在，Man类对象被回收
    //Man类对象被回收， woman.person = nil;
    //Man调用dealloc方法，Woman类对象引用计数递减为1
    //变量woman超出作用域，对Woman类对象强引用失效
    //Woman类对象持有者不存在，Woman类对象被回收

从上述示例代码可以看出，我们只需要把其中一个强引用修改为弱引用就可以打破循环引用。类似的循环引用常见的有block、NSTimer、delegate等，感兴趣的自行查阅相关资料，这里不作一一介绍。

另外，基于运行时库，如果变量或属性使用weak来修饰，当其所指向的对象被回收，那么会自动为该变量或属性赋值为nil。这一操作可以有效地避免程序出现野指针操作而导致崩溃，不过强烈不建议使用一个已经被回收的对象的弱引用，这本身对于程序设计而言就是一个bug。

2.2 weak和变量

如果一个变量被__weak修饰，代表该变量对所指向的对象具有弱引用。例如以下代码：

    Person __weak *weakPerson = nil;
    
    if (1) {
        
        Person *person = [[Person alloc] init];
        weakPerson = person;
        
        NSLog(@"%@", weakPerson);//weakPerson弱引用
    }
    
    NSLog(@"%@", weakPerson);

输出结果如下：

[1198:73648] <Person: 0x600000018120>
[1198:73648] (null)

从上述输出结果可以分析，当超出作用域后，person变量对Person对象的强引用失效。Person对象持有者不存在，所以该对象被回收。同时，weakPerson变量对Person的弱引用失效，weakPerson变量被赋值为nil。

另外需要注意的是，如果一个变量被weak修饰，那么这个变量不能持有对象示例，编译器会发出警告。例如以下代码：

Person __weak *weakPerson = [[Person alloc] init];

因为weakPerson被__weak修饰，不能持有生成的Person类对象。所以Person类对象创建完立即被释放，所以编译器会给出相应的警告：

Assigning retained object to weak variable; object will be released after assignment

2.3 weak的实现

2.3.1 weak和赋值

要解释weak赋值的实现，我们先看以下示例代码：

    Person *person = [[Person alloc] init];
    
    Person __weak *p = person;

上述对应的模拟代码如下：

    Person *person = [[Person alloc] init];
    
    Person *p;
    objc_initWeak(&p, person);
    objc_destroyWeak(&p, 0);

上述两个函数分别用来对变量p的初始化和释放，它们都调用同一个函数。如下：

    id p;

    p = 0;

    objc_storeWeak(&p, person);//对应objc_initWeak

    objc_storeWeak(&p, 0);//对应objc_destroyWeak

根据上述代码我们进行分析：
1.初始化变量
当我们使用变量弱引用指向一个对象时，通过传入变量的地址和赋值对象两个参数来调用objc_storeWeak方法。该方法内部会将对象的地址&person作为键值，把变量p的地址&p注册到weak表中。

2.释放变量当超出作用域，Person类对象被回收，此时调用objc_storeWeak(&p, 0)把变量的地址从weak表中删除。变量地址从weak表删除前，利用被回收对象的地址作为键值进行检索，把对应的变量地址赋值为nil。

2.3.2 weak和访问

当我们访问一个被__weak修饰过的变量所指向的对象时，其内部是如何实现的？我们先看以下示例代码：

    Person *person = [[Person alloc] init];

    Person __weak *p = person;
    
    NSLog(@"%@", p);

上述代码对应的模拟代码如下：

    Person *person = [[Person alloc] init];
    
    Person *p;
    objc_initWeak(&p, person);
    id tmp = objc_loadWeakRetained(&p);
    objc_autorelease(tmp);
    NSLog(@"%@", tmp);
    objc_destroyWeak(&p);

通过上述代码可以看出，访问一个被__weak修饰的变量，相对于赋值多了两个步骤：

objc_loadWeakRetained，通过该函数取出对应变量所引用的对象并retain;
把变量指向的对象注册到自动释放池。

这样一来，weak变量引用的对象就被加入到自动释放池。在自动释放池结束前都能安全使用该对象。需要注意的是，如果大量访问weak变量，就会导致weak变量所引用的对象被多次加入到自动释放池，从而导致影响性能。如果需要大量访问，我们通过__strong修饰的变量来解决，例如：

    Person __weak *p = obj;
    
    Person *tmp = p;//p引用的对象被注册到自动释放池
    
    NSLog(@"%@", tmp);
    NSLog(@"%@", tmp);
    NSLog(@"%@", tmp);
    NSLog(@"%@", tmp);
    NSLog(@"%@", tmp);

通过利用__strong中间变量的使用，p引用的对象仅注册1次到自动释放池中，有效地减少了自动释放池中的对象。

3. __unsafe_unretained

首先我们需要明确一点，如果一个变量被__unsafe_unretained修饰，那么该变量不属于编辑器的内存管理对象。该修饰符表明不保留值,即对其所指向的对象既不强引用，也不弱引用。例如以下代码：

__unsafe_unretained.png

根据上述代码分析：当超出作用域，变量p对Person类对象的强引用失效。Person类对象的持有者不存在，该对象被回收。当我们再次使用该变量的时候，因为其所表示的对象已经被回收，所以就会发生野指针崩溃。这一点区别于__weak，当被__weak修饰变量所指向的对象被回收，该变量会赋值为nil。

另外，被__unsafe_unretained修饰的变量跟__weak一样，不能持有对象实例。因为__unsafe_unretained修饰的变量不会对生成的对象实例进行保留操作，所以对象创建完即可被回收，编译器会给出相应的警告。

当我们给被__unsafe_unretained修饰的变量赋值时，必须保证赋值对象确实存在，不然程序就会发生崩溃。

4. __autoreleasing

在ARC和MRC中，autorelease作用一致，只是两者的表现方式有所不同。 1.如果返回的对象归对用者所有，如下：

    @autoreleasepool {
        
        Person __autoreleasing *p = [[Person alloc] init];
    }

上述代码模拟代码如下：

    id pool = objc_autoreleasePoolPush();
    Person *p = [[Person alloc] init];//持有
    objc_autorelease(p);
    objc_autoreleasePoolPop(pool);

2.如果返回的对象不归调用者所有，如下：

    @autoreleasepool {
        
        Person __autoreleasing *p = [Person person];
    }

上述代码模拟代码如下：

    id pool = objc_autoreleasePoolPush();
    Person *p = [Person person];
    objc_retainAutoreleasedReturnValue(p);//持有(优化后的retain方法)
    objc_autorelease(p);
    objc_autoreleasePoolPop(pool);

从上面两个例子可以看出，__autoreleasing的实现都是通过objc_autorelease()函数,只不过是持有方法有所不同而已。

至此，内存管理就介绍完毕了。由于技术有限，难免会存在纰漏，欢迎指正。转载请注明出处，万分感谢。

参考资料：
Objective-C 高级编程 iOS和OS X多线程和内存管理
Effective Objective 2.0

iOS之从MRC到ARC内存管理详解

概述

提纲

一 引用计数

二 MRC操作对象的方法

三 ARC操作对象的修饰符

具体介绍

一、引用计数

二、MRC操作对象的方法

1.alloc/new/copy/mutableCopy

1.1 持有调用者自己的对象

1.2 持有非调用者拥有的对象

2.retain

2.1 retain和属性

2.2 retain和数组

3.release

3.1 自己持有的对象自己释放

3.2 非自己持有的对象不要释放

4.autorelease

5. autorelease pool

5.1 autorelease pool和RunLoop(运行循环)

5.2 autorelease pool和降低内存峰值

三 ARC操作对象的修饰符

1. __strong

1.1 __strong与变量

1.2 strong与属性

1.3 strong的实现

2. __weak

2.1 weak和循环引用

2.2 weak和变量

2.3 weak的实现

2.3.1 weak和赋值

2.3.2 weak和访问

3. __unsafe_unretained

4. __autoreleasing

一引用计数