概述

移动设备的内存极其有限，每个app所有占用的内存是有限的。当app所占用的内存比较多时，系统会发出内存警告，这时得回收一些不需要再使用的内存空间。

任何集成了NSObject的对象都需要手动进行内存管理。因为OC对象存放于堆里面。

引用计数器

每一个OC对象都有内部有自己的引用计数器。该计数器占用4个字节。从字面可以理解为"多少人在使用这个对象"。
当对象的引用计数器为0时。该对象会才会被释放。
一个对象通过alloc、 copy 、new创建一个对象，该对象默认的引用计数器为1。

引用计数器的操作

* 给对象发送一条retain消息，对象的引用计数器+1

* 给对象发送一条release消息，对象的引用计数器-1

* 给对象发送一条retainCount消息，对获得当前对象的引用计数器值

dealloc方法

当一个对象的引用计数器值为0时，这个对象即将被销毁，器占用的内存被系统回收。对象即将被销毁前系统会自动给改对象发送一条dealloc消息。

通常重写对象的dealloc方法释放相关的资源。

* 一旦重写了dealloc方法，就必须调用[super dealloc]，并且放在最后面

* dealloc不能直接调用

* 一旦对象被回收，它占用的内存就不再可用被称之为僵尸对象。指向僵尸对象的指针被称为野指针。给僵尸对象发消息会造坏访问报错。

多对象的内存管理

多个对象进行内存管理，并且对象之间是有联系的，那么管理就会变得比较复杂。

比如在内存中有一个聊天室对象，多个Person对象共同使用者聊天室对象。

对上面的实例我们如果想做好聊天室对象跟Person对象的内存管理。需要做到下面两点

* 只要有人在使用聊天室对象聊天室对象就不能销毁

* 没有人使用聊天室对象聊天室对象需要销毁

当有Person对象使用聊天室就需要对聊天室对象的引用计数器+1。且当Person对象销毁之前需要对使用的房间对象引用计数器-1，这样就可以保证以上两点。

因此可以这样定义一个Person类

#import <Foundation/Foundation.h>

#import "ChatRoom.h"

@interface Person : NSObject

{

    ChatRoom *_cRoom;

}

- (void)setCRoom:(ChatRoom *)cRoom;

- (ChatRoom *)cRoom;

@end

#import "Person.h"

@implementation Person

- (void)setCRoom:(ChatRoom *)cRoom

{

    if (_cRoom != cRoom) {

        // 1.先对以前的对象计数器-1

        [_cRoom release];

        // 2.调用对象的retain返回对象本身

        _cRoom = [_cRoom retain];

    }

}

- (ChatRoom *)cRoom

{

    return _cRoom;

}

- (void)dealloc

{

    // 在Person对象即将销毁先对内部的聊天室对象计数器-1

    [_cRoom release];

    [super dealloc];

}

@end

Property修饰符

assign

默认Proerty修饰符为assig。比如当为Person声明一个成员属性@property int age; 编译器自动转换成@property(assign) int age;。

retain

Proerty修饰符为retain在生成的set方法会自动生成set方法的内存管理代码

@property (retain) ChatRoom *cRoom;

retain修饰生成的set方法：

- (void)setCRoom:(ChatRoom *)cRoom

{

    if (_cRoom != cRoom) {

        // 1.先对以前的对象计数器-1

        [_cRoom release];

        // 2. 调用对象的retain返回对象本身

        _cRoom = [_cRoom retain];

    }

}

nonatomic与nonnull

nonatomic是保证set方法是线程安全的，nonnull则相反。iOS开发一般使用nonatomic性能高。

@class

@class主要用于简单的引用一个类。@class与#import有着本质的区别，#import是预处理指令在程序预处理时期对#import的文件进行拷贝，而@class只是告诉编译器@class后面引用的是一个类。

import有一个特点，只要引用的文件发生的变化，那么import就会重新拷贝一次。比如现在有三个类Person、 Car、 Wheel。Person.h文件import Car.h，Car.h文件import Wheel.h。一旦wheels Wheel.h发生变化，Car.h需要重新拷贝Wheel.h并且Person.h也重新拷贝Car.h。

@class具体使用

* 在.h文件中使用@class引用一个类

* 在.m文件中使用#import包含这个类的.h文件

@class其他使用场景

对于循环依赖关系来说，比方A类引用B类，同时B类也引用A类这种嵌套包含的代码编译报错
当使用@class在两个类相互声明，就不会出现编译报错。

retain的循环引用

现在有两个类Person与Car。Person中有个成员属性car，Car中有个成员属性person。

Person类

#import <Foundation/Foundation.h>

@class Car;

@interface Person : NSObject

@property (retain) Car *car;

@end

#import "Person.h"

@implementation Person

- (void)dealloc

{

    [_car release];

    [super dealloc];

    NSLog(@"%s", __func__);

}

@end

Car类

#import <Foundation/Foundation.h>

@class Person;

@interface Car : NSObject

@property (retain) Person *per;

@end

#import "Car.h"

@implementation Car

- (void)dealloc

{

    [_per release];

    [super dealloc];

    NSLog(@"%s", __func__);

}

@end

main.m

#import <Foundation/Foundation.h>

#import "Person.h"

#import "Car.h"

int main(int argc, const char * argv[]) {

    @autoreleasepool {

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

        Car *c = [[Car alloc] init];

        // 人赋值一辆车对象

        p.car = c;

        // 车赋值人对象

        c.per = p;

        [p release];

        [c release];

    }

    return 0;

}

main.m代码执行完控制台并没有Person对象与Car对象dealloc方法的打印。因此内存两个对象并未销毁存在内存泄漏。下面画图展现main.m执行完毕内存的情况。

为什么执行p跟c的release方法，对象没有销毁。因为在给人对象赋值car对象的时候通过set方法会对car对象引用计数器+1，同理对car对象赋值人对象，人对象引用计数器也会+1。

分别执行两个对象release只是让对象应用计数器-1，因此两个对象都没有销毁。

那么我们可以尝试让其中一个类Property修饰符修改为assign。注意:修改为assign修饰一方dealloc千万不要在dealloc对对象属性进行release。否则会造成内存坏访问

此时的Person类

#import <Foundation/Foundation.h>

@class Car;

@interface Person : NSObject

// 改为assign修饰

@property (assign) Car *car;

@end

#import "Person.h"

@implementation Person

- (void)dealloc

{

    // [_car release]; 此时Propery修饰符为assign不需要对car进行release

    [super dealloc];

    NSLog(@"%s", __func__);

}

@end

autorelease

通过上面讲解，OC多对象的内存管理主要有以下几点：

* 1.在外界通过alloc、copy、new关键字创建的对象需要释放的时候发送release消息

* 2.在set方法中对赋值的对象引用计数器+1，可以使用retain关键字自动生成set方法内存管理代码

* 3.在一个对象即将要销毁前在dealloc方法中对内部引用的对象进行release。

这里就会发现，我们需要时时刻刻关注对象什么时候需要销毁时发送release消息。接下来就可以通过autorelease的机制来解决手动编写大量的对象的release代码。不需要一直再关注对象什么时候需要release。只要可以访问到对象的作用域都可以使用对象。

autorelease是一种支持引用计数器的内存管理方式，只要给对象发送一条autorelease消息会将对象放到自动释放池中。当自动释放池销毁，会对池子中的所有对象发送一条release消息。autorelease操作对象的引用计数器。当一个对象发送release消息返回时对象的本身。

#import <Foundation/Foundation.h>

#import "Person.h"

int main(int argc, const char * argv[]) {

    @autoreleasepool {

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

        // 将对象p添加到autorelease释放池

        p = [p autorelease];

        // [p release]; 这里不需要在写release 否则坏访问

    }// 自动释放池销毁会给对象中所有的对象发送一条release消息

    return 0;

}

在iOS5.0之前autorelease的写法

int main(int argc, const char * argv[]) {

    // 创建一个自动释放池

    NSAutoreleasePool *pool =[[NSAutoreleasePool alloc] init];

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

        // 将对象p添加到autorelease释放池

        p = [p autorelease];

    [pool drain]; // 自动释放池销毁会给对象中所有的对象发送一条release消息

    return 0;

}

MRC类工厂方法的编写

我们在初始化一个对象将它添加进自动释放池中

@autoreleasepool{

        // 创建一个对象

        Person *p = [[[Person alloc] init] autorelease];

    }

可见每次创建一个Person对象都需要写很长的代码，于是我们可以封装内部细节提供一个类工厂方法

/**快速创建一个Person实例*/

+ (instancetype)person;

+ (instancetype)person

{

    return [[[self alloc] init] autorelease];

}

外界调用类工厂对象初始化对象

int main(int argc, const char * argv[]) {

    @autoreleasepool{

        // 创建一个对象

        Person *p = [[[Person alloc] init] autorelease];

        // 通过类工厂方法 创建的对象默认添加进自动释放池当中

        Person *p1 = [Person person];

    }

    return 0;

}

我们想让Person在初始化后就有一个默认的名字。我们可以提供自定义构造方法。

#import <Foundation/Foundation.h>

@interface Person : NSObject

@property(nonatomic, copy) NSString *name;

/**快速创建一个Person实例*/

+ (instancetype)person;

/**自定义构造方法*/

-(instancetype)initWithName:(NSString *)name;

+(instancetype)personWithName:(NSString *)name;

@end

#import "Person.h"

@implementation Person

/**自定义构造方法*/

-(instancetype)initWithName:(NSString *)name

{

    if(self = [super init]){

        self.name = name;

    }

    return self;

}

+ (instancetype)person

{

    return [[[self alloc] init] autorelease];

}

+(instancetype)personWithName:(NSString *)name

{

    // 类方法中将对象添加进自动释放池中

    return [[self initWithName:name] autorelease];

}

@end

上面的代码会发现在MRC类方法中生成的对象默认内部将其添加自动释放池当中，其实这也是苹果的规范。苹果Foundation框架中通过类方法创建的对象都是autorelease。

ARC的内存管理

ARC是编译器的特性，而不是运行时特性，跟其他语言的垃圾回收有着本质的区别。ARC原理就是在编译阶段为我们在必要的时候添加release这些代码。

ARC的判断原则

* 只要还有一个强指针指向对象，对象就会保持在内存中

ARC与MRC的混编

* 在ARC项目中执行某个文件使用MRC -fno-objc-arc

* 在MRC项目中执行某个文件使用ARC -fobjc-arc

使用Xcode将一个MRC工程转化成ARC项目

巴特西

OC开发系列-内存管理

概述