黑马程序员--Objective-C之--OC中的内存管理

------IOS培训期待与您交流！ -------

对于面向对象的变成语言，程序需要不断地创建对象。

初始，创建的所有程序通常都有指针指向它，程序可能需要访问这些对象的实例变量或调用这些对象的方法，随着程序的不断执行，程序再次创建了一些新的对象，

而那些老的对象已经不会再被调用，也不再有指针指向他们，如果程序没有回收他们占用的内存，就会出现内存泄露。

如果程序一直泄露内存，那么可用内存就会越来越少，直到没有足够的内存，程序將会崩溃。目前，主要有两种管理内存的技术，一是引用计数，二是垃圾回收。

iOS平台目前只支持引用计数，Mac平台支持垃圾回收。

引用计数通过给每个对象维护一个引用计数器，记录该对象当前被引用的次数。当对象增加一次引用时，计数器加1；对象失去一次引用时，计数器减1；当引用计数为0时，标

志着该对象的生命周期结束，系统自动回收该对象。

iOS的引用技术分为手动引用计数和自动引用计数(ARC)。

一、手动引用计数

手动引用计数，就是右开发人员自己控制对象的引用计数，相关方法如下：

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

2、给对象发送一条retain消息,可以使引用计数器值+1

3、给对象发送一条release消息,可以使引用计数器值-1

4、可以给对象发送retainCount消息获得当前的引用计数器值

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

一个对象被销毁时，系统会自动向对象发送一条dealloc消息。所以一般会重写dealloc方法，在这里释放相关资源，dealloc就像对象的遗言。

一旦重写了dealloc方法，就必须调用[super dealloc]，并且放在最后面调用。要特别注意的时，不要直接调用dealloc方法，否则当系统调用dealloc方法，程序会崩溃。

 

    //Person.h  
    @interface Person : NSObject  
      
    @property int age;  
      
    @end  
      
    //Person.m  
    @implementation Person  
    // 当一个Person对象被回收的时候，就会自动调用这个方法 
 
    - (void)dealloc  
    {  
        NSLog(@"Person对象被回收");  
          
        // super的dealloc一定要调用，而且放在最后面  
        [super dealloc];  
    }  
    @end  
      
    //main.c  
    int main()  
    {  
        
        Person *p = [[Person alloc] init];     // alloc之后，该对象的计数器为1  
          
        NSLog(@"计数器：%ld", [p retainCount]);      // 查看该对象的引用计数值  
      
        [p release];  //释放该对象，否则引起内存泄露  
                
        return 0;  
    }  

二、成员变量的引用计数

以上只是一个简单类的内存管理，如果某个类的成员变量也引用其他类，事情就变得很复杂。为了做好内存管理，有4个基本原则：

1.想使用（占用）某个对象，就应该让对象的计数器+1（让对象做一次retain操作）

2.不想再使用（占用）某个对象，就应该让对象的计数器-1（让对象做一次release）

3.谁retain，谁release

4.谁alloc，谁release

 

    //Person.h，Car是已经定义好的类  
    @interface Person : NSObject  
    {  
        Car *_car;  
    }  
      
    - (void)setCar:(Car *)car;  
    - (Car *)car;  
    @end  
      
    //Person.m  
    @implementation Person  
    - (void)setCar:(Car *)car  
    {  
        if (car != _car)  //一定要判断，否则_car指向的对象会发生内存泄露  
        {  
            // 对当前正在使用的车（旧车）做一次release  
            [_car release];  
              
            // 对新车做一次retain操作  
            _car = [car retain];  
        }  
    }  
      
    - (Car *)car  
    {  
        return _car;  
    }  
      
    - (void)dealloc     //一定重写该方法，否则_car指向的对象没法释放  
    {  
        // 当人不在了，代表不用车了  
        // 对车做一次release操作  
        [_car release];  
          
        NSLog(@"%d岁的Person对象被回收了", _age);  
          
        [super dealloc];  
    }  
      
    @end  
      
      
    int main()  
    {  
        
        Person *p = [[Person alloc] init];  //Person对象的引用计数为1
  
        Car *c = [[Car alloc] init];  //Car对象的引用计数为1  
  
        p.car = c;   //Car对象的引用计数变成2  
          
        [c release];    //Car对象的引用计数变成1  
          
        [p release];   //Car对象的引用计数变成0，Person对象的引用计数变成0    
          
        return 0;  
    }  

三、带有内存管理的合成存取方法

OC语言提供了了@property、@synthesize指令用于简化setter和getter方法，同样也提供了相应的指示符用于内存管理。

（一）、set方法内存管理相关的参数

1、retain : release旧值，retain新值（适用于OC对象类型）

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

3、copy : release旧值，copy新值 (一般用于NSString*)

（二）、是否要生成set方法

1、readwrite : 同时生成setter和getter的声明、实现(默认)

2、readonly : 只会生成getter的声明、实现

（三）、多线程管理

1、nonatomic : 性能高 (一般就用这个)

2、atomic : 性能低（默认）

（四）、setter和getter方法的名称

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

2、getter : 决定了get方法的名称(一般用在BOOL类型)

    //Person.h，Car是已经定义好的类  
    @interface Person : NSObject  
    {  
        Car *_car;  
    }  
    // retain : 生成的set方法里面，release旧值，retain新值  
    @property (nonatomic,retain) Car *car;  
    @end  
      
    //Person.m  
    @implementation Person  
    - (void)setCar:(Car *)car  
    /*这段代码，由系统自动生成 
    { 
        if (car != _car)  //一定要判断，否则_car指向的对象会发生内存泄露 
        { 
            // 对当前正在使用的车（旧车）做一次release 
            [_car release]; 
             
            // 对新车做一次retain操作 
            _car = [car retain]; 
        } 
    } 
     
    - (Car *)car 
    { 
        return _car; 
    } 
    */  
    - (void)dealloc     //一定重写该方法，否则_car指向的对象没法释放  
    {  
        // 当人不在了，代表不用车了  
        // 对车做一次release操作  
        [_car release];  
          
        NSLog(@"%d岁的Person对象被回收了", _age);  
          
        [super dealloc];  
    }  
      
    @end  
      
      
    int main()  
    {  
        
        Person *p = [[Person alloc] init];  //Person对象的引用计数为1
  
        Car *c = [[Car alloc] init];  //Car对象的引用计数为1   
 
        p.car = c;   //Car对象的引用计数变成2  
          
        [c release];    //Car对象的引用计数变成1  
          
        [p release];   //Car对象的引用计数变成0，Person对象的引用计数变成0    
          
        return 0;  
    }  

四、循环引用

利用retain，release方法，可以解决绝大部分的内存管理问题。

但是，有一种的特殊的情况需要引起注意。那就是循环引用，比如A对象retain了B对象，B对象retain了A对象；这样会导致A对象和B对象永远无法释放。

解决方案：当两端互相引用时，应该一端用retain、一端用assign

 

    //Person.h  
    @interface Person : NSObject  
      
    @property (nonatomic, retain) Card *card;    //在这用retain  
      
    @end  
      
    //Person.m  
    @implementation Person  
      
    - (void)dealloc  
    {  
        NSLog(@"Person被销毁了");  
        [_card release];  
          
        [super dealloc];  
    }  
      
    @end  
      
    //Card.h  
    @interface Card : NSObject  
      
    @property (nonatomic, assign) Person *person;  //用assign，否则造成循环引用，导致内存泄露  
      
    @end  
      
    @implementation Card  
      
    //Card.m  
    - (void)dealloc  
    {  
        NSLog(@"Car被销毁了");     
        // [_person release];    //因为用的是assign，不需要release    
        [super dealloc];  
    }  
      
    @end  

五、autorelease

OC提供了autorelease语法，系统可以將很多对象放到一个自动释放池中，在某个时刻统一release一次。这样就不用再次调用release方法。

（一）、autorelease的基本用法：

1、创建对象时，马上调用autorelease方法([[[Person alloc] init] autorelease])，会将对象放到一个自动释放池中、

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

3、调用autorelease方法会返回对象本身

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

（二）、autorelease的好处

1、不用再关心对象释放的时间

2、不用再关心什么时候调用release

（三）、autorelease的使用注意

1、占用内存较大的对象不要随便使用autorelease

2、占用内存较小的对象使用autorelease，没有太大影响

3、alloc之后调用了autorelease，不能再调用release

4、不能连续调用多次autorelease

（四）、自动释放池的创建方式

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

1、iOS 5.0前

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

[pool release];

2、iOS 5.0 开始

@autoreleasepool
{

}

 

    //Person.h  
    @interface Person : NSObject  
      
    @property (nonatomic, assign) int age;  
      
    @end  
      
    //Person.m  
    @implementation Person
  
    - (void)dealloc  
    {  
        NSLog(@"Person---dealloc");  
          
        [super dealloc];  
    }  
      
    //main.c  
    int main()  
    {  
      
      
        @autoreleasepool {   //自动释放池  
      
            Person *p = [[[Person alloc] init] autorelease];  //调用autorelease方法，將该对象放入自动释放池  
            //[p release];   不需要调用release方法  
        }    
          
        return 0;  
    }  
    @end  

六、ARC

ARC是自iOS 5之后增加的新特性，完全消除了手动管理内存的烦琐，编译器会自动在适当的地方插入适当的retain、release、autorelease语句。

你不再需要担心内存管理,因为编译器自动处理内存管理。ARC 是编译器特性，而不是 iOS 运行时特性，它也不是类似于其它语言中的垃圾收集器。

ARC 和手动内存管理性能是一样的，有时还能更加快速，因为编译器还可以执行某些优化。

在介绍ARC的使用之前，先说明两个概念：强指针和弱指针。

（1）强指针(strong)：默认所有实例变量和局部变量都是strong指针，只要有强引用指向对象，该对象就不会被释放。

（2）弱指针(weak)：若指针指向的对象，如果没有其他的强指针指向该对象，该对象就会被释放。

弱指针指向的对象被释放后，弱指针会自动变为nil指针，不会引发野指针错误。

ARC的使用非常简单，只要將该项目设置ARC模式即可。但是要注意以下情况：

（1）不允许调用release、retain、autorelease、retainCount

（2）允许重写dealloc，但是不允许调用[super dealloc]

（3）@property的参数

   * strong ：成员变量是强指针（适用于OC对象类型）

   * weak ：成员变量是弱指针（适用于OC对象类型）

   * assign : 适用于非OC对象类型

（4）以前的retain改为用strong

    //Person.h  
    @interface Person : NSObject  
      
    @property (nonatomic, assign) int age;  
    @property (nonatomic, strong) Dog *dog;  
    @end  
      
    //Person.m  
    @implementation Person  
    - (void)dealloc  
    {  
        NSLog(@"Person---dealloc");  
          
        //[super dealloc];  不能调用该方法了  
    }  
      
    //main.c  
    int main()  
    {  
        Dog *d = [[Dog alloc] init];  //不能使用autorelease方法  
          
        Person *p = [[Person alloc] init]; 
 
        p.dog = d;  
          
        d = nil;  
          
        //[p release];    release方法也不能使用了  
         
        NSLog(@"%@", p.dog);  
          
        return 0;  
    }  
    @end  

七、ARC的循环引用

ARC的循环引用的解决方法是，一端用strong，一端用weak。

 

//Person.h  
@interface Person : NSObject  
  
@property (nonatomic, strong) Dog *dog; 
 
@end  
  
//Person.m  
@implementation Person  
- (void)dealloc  
{  
    NSLog(@"Person---dealloc");  
      
    //[super dealloc];  不能调用该方法了  
}  
  
//Dog.h  
@interface Dog : NSObject  
  
@property (nonatomic, weak) Person *person;   //必须用weak  
  
@end  
  
//Dog.m  
@implementation Dog  
- (void)dealloc  
{  
    NSLog(@"Dog--dealloc");  
}  
@end