【Objective-C学习笔记】内存管理

一、基本原理

1、为什么进行内存管理

（1）移动设备的内存极其有限，每个app所能占用的内存是有限制的
（2）当app所占用的内存较多时，系统会发出内存警告，这时得回收一些不需要再使用的内存空间。比如回收一些不需要使用的对象、变量等
（3）管理范围： 任何继承了NSObject的对象，对其他基本数据类型（int、char、float、double、struct、enum等）无效

（4）局部变量存储在栈中，代码块结束后，内存会自动回收；对象存储在堆中，系统不会自动回收，需要我们手动回收

2、对象的基本结构

（1）引用计数器

1> 对象中都有引用计数器，是一个整数，表示“对象被引用的次数”
2> 每个OC对象内部专门有 4个字节的存储空间来存储引用计数器

（2）引用计数器的作用

1> 当使用alloc、new、copy创建一个新对象时，新对象的引用计数器默认是1

// 引用计数器默认为1
Person *p = [[Person alloc] init];    //计数器=1

2> 当计数器为0，对象所占内存被回收，在程序运行中，只要计数器不为0，它占用的内存就不会被回收，除非程序结束

（3）引用计数器的操作

1> 发送 retain消息，计数器+1

// retain方法返回的是对象本身
    [p retain];    // 计数器=2

2> 发送retainCount消息，获得当前的引用计数器数值

    NSUInteger s = [p retainCount];   
    NSLog(@"计数器的个数是：%ld", s);    // 2

3> 发送release消息，计数器-1

// release方法没有返回值
    [p release];    // 计数器=1

（4）对象的销毁

1> 当对象的引用计数器数值为0，对象将被销毁，内存被系统回收

    [p release];    // 计数器=0，对象被回收

2> 当对象被销毁时，系统自动 给对象发送一条dealloc消息，一般会重写dealloc方法，在里面释放对象所占用的资源。一旦重写dealloc方法，就必须调用[super dealloc];，并且放在最后面调用

@implementation Person
// 当一个Person对象被回收的时候，就会自动调用这个方法
- (void)dealloc
{
    NSLog(@"Person对象被回收");
    [super dealloc];
}
@end

（5）注意经典错误--野指针错误

对象一旦被回收了，它占用的内存就不再可用，坚持使用会导致程序崩溃（野指针错误）
1> 僵尸对象：对象所占的内存被回收的对象（上面的Person对象就是僵尸对象），一旦成为僵尸对象，就不能再使用，包括发送retain方法。

2> 野指针：指向僵尸对象（不可用内存）的指针（上面的指针变量p为野指针），给野指针发送消息会报错（EXC_BAD_ACCESS）

    // [p release];    野指针错误
    // [p retain];    野指针错误，已经成为僵尸对象，就算调用的方法是retain也不行

3> 空指针：没有指向任何东西的指针（空指针存储的东西是nil、NULL、0）

// 如果在对象被销毁的代码之后指针p变成空指针。
    p = nil;

// 在空指针之后发送消息就不会报错了，OC中不存在空指针错误
    [p release];

二、Xcode设置

1、取消ARC（自动引用计数）

（1）在Xcode6.2中，新建的项目中 ，默认ARC是开启，但是我们现在的学习阶段需要先手动关闭这个功能。

（2）点击 项目名 --> Build Settings --> 搜索auto --> 找到Automatic Reference Counting --> 选择NO

2、开启僵尸对象监控

默认情况下，这个是不会打开的，为了调试方便，我们应该打开

三、内存管理原则

1、多对象内存管理

#import <Foundation/Foundation.h>
// 人和书

// 书
@interface Book : NSObject
@end

@implementation Book
// Book对象被回收，调用dealloc方法
- (void)dealloc
{
    NSLog(@"Book对象被回收");
    [super dealloc];
}
@end

// 人
@interface Person : NSObject
@property Book *book;
@end

@implementation Person
// 重写书的setter
- (void)setBook:(Book *)book
{
    _book = [book retain];    // Person对象占用Book对象，那么Book对象的引用计数器+1
}

- (void)dealloc
{
    [_book release];    // Person对象被销毁，那么它内部的Book对象引用计数器-1，
    NSLog(@"Person对象被回收");
    [super dealloc];
}
@end

int main()
{
    Book *b = [[Book alloc] init];    // Book对象引用计数器=1
    Person *p = [[Person alloc] init];    // Person对象引用计数器=1
    
    // p拥有b这本书
    [p setBook:b];  //p.book = b;    // Book对象引用计数器+1=2
    
    [b release];    // Book对象引用计数器-1=1
    b = nil;    // Book对象被销毁了，那么让b变成空指针
    [p release];    // Person对象引用计数器-1=0，被销毁。调用dealloc方法，<span style="font-family: Arial, Helvetica, sans-serif;">Book对象引用计数器-1=0</span>

    return 0;
}

// 执行结果
 Book对象被回收
 Person对象被回收

如果是多个对象之间的内存管理，就需要遵守

（1）只要你使用这个对象，就让对象的计数器+1
（2）当你不再使用这个对象，就让对象的计数器-1

2、内存管理的原则：

（1）谁创建，谁release

如果通过alloc、new、copy创建了一个对象，那么必须调用release或者autoreelease

（2）谁retain，谁release

只要调用了retain，无论对象是如何生成的，都需要调用release

（3）有始有终

有加就有减，只要曾经让对象的计数器+1，就必须在最后让对象计数器-1

四、set方法的内存管理

1、set方法的代码规范

（1）基本数据类型：直接赋值

- (void)setAge:(int)age
{
    _age = age;
}

（2）OC对象类型

- (void)setCar:(Car *)car
{
    // 1.先判断是不是新传进来对象
    if (car != _car)
    {
        // 2.对旧对象做一次release
        [_car lease];

        // 3.对新对象做一次retain
        _car = [car retain];
    }
}

2、dealloc方法的代码规范

（1）一定要调用[suer dealloc]，而且放到最后面
（2）对self（当前）所拥有的其他对象做一次release

- (void)dealloc
{
    [_car release];
    [super dealloc];
}

五、@property参数

1、控制set方法的内存管理

（1）retain：

release旧值，retain新值

@property (retain) Book *book;
// 编译特性
- (void)setBook:(Book *)book
{
    if (_book != book)
    {
        [_book release];
        _book = [book retain];
    }
}

（2）assign：

直接赋值（默认，适用于非OC对象类型）

@property (assign) int age;

（3）copy：

release旧值，copy新值（一般用于NSString *）

2、控制是否生成set方法

（1）readwrite：

同时生成setter和getter的声明、实现（默认）

@property (readwrite, assign) int height;

（2）readonly：

只会生成getter的声明、实现

3、多线程管理

（1）nonatomic：性能高（一般就用这个）

@property (nonatomic, assign) int age;

（2）atomic：性能低（默认）

4、控制set方法和get方法的名称

（1）setter：

决定了set方法的名称，一定要有个冒号

@property (setter = setAbc:) int abc;

（2）getter：

决定了get方法的名称（一般用在BOOL类型）

// 返回BOOL类型的方法名一般以is开头
@property (getter = isRich) BOOL rich;

六、循环引用之@class关键字

1、场景模拟

<pre name="code" class="plain">// Person.h文件
#import <Foundation/Foundation.h>
// #import "Card.h"
@class Card.h
// Person类的声明
@interface Person : NSObject
@property (nonatomic, retain) Card *card;
@end

// Person.m文件
#import "Person.h"
#import "Card.h"
// Person类的实现
@implementation Person
-(void)dealloc
{    
    NSLog(@"Person对象被回收了");
    [_card release];   
    [super dealloc];
}
@end

<pre name="code" class="plain">// Card.h文件
#import <Foundation/Foundation.h>
// #import "Person.h"
@class Person.h
// Card类的声明
@interface Car : NSObject
@property (nonatomic, retain) Person *person;
@end

#import "Card.h"
#import "Person.h"
//Card类的实现
@implementation Card
- (void)dealloc
{
    NSLog(@"Card对象被回收了");    
    [_person release];    
    [super dealloc];
}
@end

// main函数
#import <Foundation/Foundation.h>
#import "Person.h"
#import "Card.h"

int main()
{
    // p - 1
    Person *p = [[Person alloc] init];
    // c - 1
    Card *c = [[Card alloc] init];

    // c - 2
    p.card = c;
    // p - 2
    c.person = p;
    
    // c - 1
    [c release];
    // p - 1
    [p release];
    
    return 0;
}

1、循环retain

Person对象retain了Card对象，Card对象retain了Person对象。这样会导致Person对象和Card对象永远无法释放

2、@class的作用

（1）仅仅告诉编译器，某个名称是一个类
（2）当使用@class在两个类相互声明，就不会出现编译报错

3、开发中引用一个类的规范

（1）在.h文件中用@class来声明类
（2）在.m文件中用#import来包含类的所有东西

4、两端循环引用的解决方案

（1）一端用retain

（2）一端用assign

使用assign的一端，在dealloc方法中就不用再release了。

// Card.h文件
#import <Foundation/Foundation.h>
// #import "Person.h"
@class Person.h
// Card类的声明
@interface Car : NSObject
@property (nonatomic, assign) Person *person;
@end

5、@class和#import的区别

1、@class只是告诉编译器，在A.h文件中的B是一个类，只是一个声明。至于B类中有什么内容，不需要关心，等实现文件中真正要用到时，才会真正去查看B类中信息；#import方式会拷贝被引用类的所有信息，包括被引用类的变量和方法。

2、如果有上百个头文件都#import了同一个文件，或者这些文件依次被#improt,那么一旦最开始的头文件稍有改动，后面引用到这个文件的所有类都需要重新编译一遍，这样的效率也是可想而知的，而相对来讲，使用@class方式就不会出现这种问题了。

3、在.m实现文件中，如果需要引用到被引用类的实体变量或者方法时，还需要使用#import方式引入被引用类。

七、autorelease

1、autorelease的基本用法

（1）会将对象放到一个自动释放池中

（2）当自动释放池被销毁时，会对池子里面的所有对象做一次release操作

（3）会返回对象本身

（4）调用完autorelease方法后，对象的计数器不变

2、autorelease的好处

（1）不用再关心对象释放的时间
（2）不用再关心什么时候调用release

3、autorelease的使用注意

（1）占用内存较大的对象不要随便使用autorelease
（2）占用内存较小的对象使用autorelease，没有太大的影响

4、错误写法

（1）alloc之后调用了autorelease，又调用了release

@autoreleasepool
{
    Person *p = [[[Person alloc] init] autorelease];
    // [p release];     报错，野指针错误
}

（2）连续多次调用autorelease

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

5、自动释放池

（1）在iOS程序运行过程中，会创建无数个池子。这些池子都是以栈这种数据类型存在（先进后出）
（2）当一个对象调用autorelease方法时，会将这个对象放到栈顶的释放池

6、自动释放池的创建方式

（1）iOS 5.0前

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

[pool release]; //[pool drain];

（2）iOS 5.0开始

@autoreleasepool
{

}

7、autorelease的应用

（1）系统自带的方法里面没有包含alloc、new、copy，说明返回的对象都是autorelease的
（2）开发中经常会提供一些类方法，快速创建一个已经autorelease过的对象

// 创建对象时不要直接用类名，一般用self
+(id)person
{
    return [[[self alloc] init] autorelease];
}