iOS开发-Day20-OC 手动内存管理

• 为什么要进行内存管理。

  由于移动设备的内存极其有限，所以每个APP所占的内存也是有限制的，当app所占用的内存较多时，系统就会发出内存警告，这时需要回收一些不需要再继续使用的内存空间，比如回收一些不再使用的对象和变量等。

  管理范围：任何继承NSObject的对象，对其他的基本数据类型无效。

  本质原因是因为对象和其他数据类型在系统中的存储空间不一样，其它局部变量主要存放于栈中，而对象存储于堆中，当代码块结束时这个代码块中涉及的所有局部变量会被回收，指向对象的指针也被回收，此时对象已经没有指针指向，但依然存在于内存中，造成内存泄露。

• 内存管理黄金法则：

  The basic rule to apple is everything thatincreases the reference counter with alloc,[mutable]copy[WithZone:] or retainis in charge of the corresponding [auto]release.

  如果一个对象使用了alloc，[mutable] copy，retain，那么你必须使用相应的release或autonrelease

• 对象的基本结构

  每个OC对象都有自己的引用计数器，是一个整数表示对象被引用的次数，即现在有多少东西在使用这个对象。对象刚被创建时，默认计数器值为1，当计数器的值变为0时，则对象销毁。每个OC对象内部，都专门有4个字节的存储空间来存储引用计数器。

• 引用计数器的作用

  判断对象要不要回收的唯一依据就是计数器是否为0，若不为0则存在。

• 操作

  给对象发送消息，进行相应的计数器操作。

  Retain消息：使计数器+1，改方法返回对象本身

  Release消息：使计数器-1（并不代表释放对象）

  retainCount消息：获得对象当前的引用计数器值

• 对象的销毁

  当一个对象的引用计数器为0时，那么它将被销毁，其占用的内存被系统回收。

  当对象被销毁时，系统会自动向对象发送一条dealloc消息，一般会重写dealloc方法，在这里释放相关的资源，dealloc就像是对象的“临终遗言”。一旦重写了dealloc方法就必须调用[super dealloc]，并且放在代码块的最后调用（不能直接调用dealloc方法）。

  一旦对象被回收了，那么他所占据的存储空间就不再可用，坚持使用会导致程序崩溃（野指针错误）。

• 相关概念和使用注意

  野指针错误：访问了一块坏的内存（已经被回收的，不可用的内存）。

  僵尸对象：所占内存已经被回收的对象，僵尸对象不能再被使用。（打开僵尸对象检测）

  空指针：没有指向任何东西的指针（存储的东西是0,null，nil），给空指针发送消息不会报错

  注意：不能使用[p retaion]让僵尸对象起死复生。

• 内存管理原则

  • 原则

    只要还有人在使用某个对象，那么这个对象就不会被回收；

    只要你想使用这个对象，那么就应该让这个对象的引用计数器+1；

    当你不想使用这个对象时，应该让对象的引用计数器-1；

  • 谁创建，谁release

    如果你通过alloc,new,copy来创建了一个对象，那么你就必须调用release或者autorelease方法

    不是你创建的就不用你去负责

  • 谁retain，谁release

    只要你调用了retain，无论这个对象时如何生成的，你都要调用release

  • 总结

    有始有终，有加就应该有减。曾经让某个对象计数器加1，就应该让其在最后-1.

代码规范：

1、只要调用了alloc，就必须有release(autorelease)
2、Set方法的代码规范

 //（1）基本数据类型：直接复制
-（void）setAge:(int)age
{
    _age=age;
}
//（2）OC对象类型
-（void）setCar:(Car *)car
{
    //1.先判断是不是新传进来的对象
    If(car!=_car)
    {
        //2 对旧对象做一次release
        [_car release];//若没有旧对象，则没有影响
        //3.对新对象做一次retain
        _car=[car retain];
    }
}

3、dealloc方法的代码规范

//一定要[super dealloc]，而且要放到最后

//对self（当前）所拥有的的其他对象做一次release操作

-（void）dealloc
{
    [_car release];
    [super dealloc];
}

• @property的内存参数

Retain(strong):对对象release旧值，retain新值（适用于OC对象类型）
Assign(week):直接赋值（默认，适用于非oc对象类型）
Copy:release旧值，copy新值

• 内存管理中的循环引用问题以及解决

  案例：每个人有一张身份证，每张身份证对应一个人，不能使用#import的方式相互包含，这就形成了循环引用。
  新的关键字：@class 类名；——解决循环引用问题，提高性能
  @class仅仅告诉编译器，在进行编译的时候把后面的名字作为一个类来处理。
  （1）@class的作用：声明一个类，告诉编译器某个名称是一个类
  （2）开发中引用一个类的规范

      1）在.h文件中使用@class来声明类
      2）在.m文件中真正要使用到的时候，使用#import来包含类中的所有东西
  

  （3）两端循环引用的解决方法
  一端使用retain,一端使用assign（使用assign的在dealloc中也不用再release）

• Autorelease

  (一)基本用法

  （1）会将对象放到一个自动释放池中
  
  （2）当自动释放池被销毁时，会对池子里的所有对象做一次release
  
  （3）会返回对象本身
  
  （4）调用完autorelease方法后，对象的计数器不受影响（销毁时影响）
  

  (二)好处

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

  (三)使用注意

  (1)占用内存较大的对象，不要随便使用autorelease，应该使用release来精确控制
  
  (2)占用内存较小的对象使用autorelease，没有太大的影响
  

  (四)错误写法

  （1）连续调用多次autorelease，释放池销毁时执行两次release(-1吗？)
  
  （2）Alloc之后调用了autorelease，之后又调用了release。
  

  (五)自动释放池

  （1）在ios程序运行过程中，会创建无数个池子，这些池子都是以栈结构（先进后出）存在的。
  
  （2）当一个对象调用autorelease时，会将这个对象放到位于栈顶的释放池中
  

下面的例子进一步详解了手动内存管理：

//Car.h
#import <Foundation/Foundation.h>
#import "Engine.h"
@interface Car : NSObject
{
    //成员变量
    Engine *_eng;
}
-(void)setEng:(Engine *)eng;
-(Engine *)eng;
-(void)run;
@end
#import "Car.h"
//Car.m
@implementation Car
//第一次
//-(void)setEng:(Engine *)eng{
//    
//    //对于传入eng，引用计数+1
//    _eng=[eng retain];
//    //_eng=eng;
//}
//第二次
//-(void)setEng:(Engine *)eng{
//    //如果不加release 内存泄露
//    [_eng release];
//    //对于传入eng，引用计数+1
//    _eng=[eng retain];
//    //_eng=eng;
//}
//第三次
//-(void)setEng:(Engine *)eng{
//    
//    if (eng!=_eng) {
//        //如果不加release 内存泄露
//        [_eng release];
//        //对于传入eng，引用计数+1
//        _eng=[eng retain];
//        //_eng=eng;
//    }
//    
//}
//简便写法
-(void)setEng:(Engine *)eng{

    [eng retain];
    [_eng release];
    _eng=eng;

}

-(Engine *)eng{
    return _eng;
}
-(void)run{
    NSLog(@"run");
}
- (void)dealloc
{
    //根据谁拥有谁释放的原则，再次释放对象
    NSLog(@"car销毁");
    [_eng release];
    [super dealloc];
}
@end
//Engine.h
#import <Foundation/Foundation.h>
@interface Engine : NSObject
@end
//Engine.m
#import "Engine.h"
@implementation Engine
- (void)dealloc
{
    NSLog(@"eng销毁");
    [super dealloc];
}
@end

//main.m
#import <Foundation/Foundation.h>
#import "test.h"
#import "Car.h"
int main(int argc, const char * argv[]) {
    @autoreleasepool {
//        //第一次测试
//        Car *car=[Car new];
//        Engine *eng=[Engine new];
//        //实际需要计数引用+1
//        car.eng=eng;
//        //eng释放
//        [eng release];
//        //car释放
//        [car release];

//        //第二次测试
//        Car *car=[Car new];
//        Engine *e1=[Engine new];
//        car.eng=e1;
//        [e1 release];//e1不会被释放
//        
//        Engine *e2=[Engine new];
//        car.eng=e2;
//        [e2 release];
//        [car release];

        //第三次测试
        Car *car=[Car new];

        Engine *e=[Engine new];
        car.eng=e;
        [e release];

        car.eng=e;

        [car release];


    }
    return 0;
}

-15.8.7
-15.8.12