首页 > 代码库 > Objective-C的内存管理（一）黄金法则的理解

Objective-C的内存管理（一）黄金法则的理解

2024-10-28 03:21:39   208人阅读

一、内存管理黄金法则：

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

 

 

二、内存管理类型分类

基本类型和C语言的类型：如：

int,short,char,struct,enum,union等类型

OC类型：任何继承于NSObject对象都属于OC的类型。

我们讲的内存管理实际上是对OC类型的内存管理，它对基本数据类型和C语言的类型并不管用。

 

 

三、C和C＋＋内存管理的不足

技术分享

 

如上，又3个引用指向了这一块内存，任何一个调用了free方法释放这个内存，而其余的引用在不知道的情况下继续使用这块内存的时候，就会出现问题。何时由谁去释放这块内存，这就是C和C++在内存管理上的混乱。

 

 

四、OC对象在内存中的结构

所有的OC类型的对象的结构如下，这个对象的内存在包含自己的变量和方法的基础上，还有一个包含retainCount的引用计数。

每一个OC对象都有一个4个字节的retainCount的计数器。表示当前对象被引用的计数。如果计数为0，那么就真正的去释放这个对象。

 

技术分享
 

规则：

1、Objective-C类中实现了引用计数器，对象知道自己当前被引用的次数

2、最初对象的计数器为1

3、如果需要引用对象，可以给对象发送一个retain消息，这样对象的计数器就加1

4、当不需要引用对象了，可以给对象发送release消息，这样对象计数器就减1

5、当计数器减到0，自动调用对象的dealloc函数，对象就会释放内存

6、计数器为0的对象不能再使用release和其他方法

 

五、举例说明

比如有一个引擎类Engine，有一个汽车类Car，Car里面有一歌Engine的实例变量，一个setter和getter方法。具体如下

 

[plain] view plaincopy
 
  1. #import "Car.h"  
  2.   
  3. @implementation Car  
  4.   
  5.   
  6. -(void)setEngine:(Engine*) engine  
  7. {  
  8.      _engine=engine;  
  9. }  
  10. -(Engine*)engine  
  11. {  
  12.     return _engine;  
  13. }  
  14.   
  15. -(void)dealloc  
  16. {  
  17.     NSLog(@"Car is dealloc");  
  18.     [super dealloc];  
  19. }  
  20. @end  



 

上面写的是一个简单的类，当让这样写是有问题，所以需要一步步的改进。

第一步改进：

先使用它看问题的所在,在main方法里面如下使用：

 

[plain] view plaincopy
 
  1. //先创建一个引擎  
  2. Engine* engine1=[[Engine alloc]init];  
  3. [engine1 setID:1];  
  4. //在创建一个汽车，设置汽车的引擎  
  5. Car* car=[[Car alloc]init];//retainCount=1  
  6. [car setEngine:engine1];  
  7. /*分析：在这里，现在有两个引用指向这个Engine对象，engine1和Car中的_engine,可是这个Engine对象的引用计数还为1，因为在  
  8.  set方法中，并没有使用retain。那么不管是哪个引用调用release，那么另外一个引用都会指向一块释放掉的内存，那么肯定  
  9.  会发生错误。所以需要在set方法中加以改进。*/  


第二步改进：

 

setter方法改进

 

[plain] view plaincopy
 
  1. -(void)setEngine:(Engine*) engine  
  2. {  
  3.      _engine=[engine retain];//多了一个引用，retainCount+1  
  4. }  

再在main中使用它

 

 

[plain] view plaincopy
 
  1.  //先创建一个引擎  
  2.  Engine* engine1=[[Engine alloc]init];  
  3.  [engine1 setID:1];  
  4.  //在创建一个汽车，设置汽车的引擎  
  5.  Car* car=[[Car alloc]init];//retainCount=1  
  6.  [car setEngine:engine1];//retainCount=2，因为使用了retain，所以retainCount=2，  
  7.   
  8.  //假设还有一个引擎  
  9.  Engine* engine2=[[Engine alloc]init];  
  10.  [engine2 setID:2];  
  11.    
  12.  //这个汽车要换一个引擎，自然又要调用settr方法         
  13.   [car setEngine:engine2];  
  14.     
  15.  /*分析：在这里，汽车换了一个引擎，那么它的_engine就不在指向engine1的哪个对象的内存了，而是换成了engine2，也就是说engine1的哪个对象指向的内存的引用只有一个  
  16. 可是它的retainCount是两个，这就是问题的所在了。所以仍然需要改进*/  


第三步改进：

 

 

[plain] view plaincopy
 
  1. -(void)setEngine:(Engine*) engine  
  2. {  
  3.      [_engine release];//在设置之前，先release，那么在设置的时候，就会自动将前面的一个引用release掉  
  4.     _engine=[engine retain];//多了一个引用，retainCount+1  
  5. }  

再在main‘中使用

 

 

[plain] view plaincopy
 
  1. //先创建一个引擎  
  2. Engine* engine1=[[Engine alloc]init];  
  3. [engine1 setID:1];  
  4. //在创建一个汽车，设置汽车的引擎  
  5. Car* car=[[Car alloc]init];//retainCount=1  
  6. [car setEngine:engine1];//retainCount=2，因为使用了retain，所以retainCount=2，  
  7.   
  8. //如果进行了一个误操作，又设置了一次engine1       
  9.  [car setEngine:engine1];  
  10.    
  11. /*分析：那么，又要重新调用一次setter方法，这根本就是无意义的操作，浪费资源，所以要在设置之间加上判断*/  


第四步改进：

 

 

[plain] view plaincopy
 
  1. -(void)setEngine:(Engine*) engine  
  2. {  
  3.    if(_engine!=engine){//判断是否重复设置  
  4.            [_engine release];//在设置之前，先release，那么在设置的时候，就会自动将前面的一个引用release掉  
  5.            _engine=[engine retain];//多了一个引用，retainCount+1  
  6.       }  
  7.  }  


第五步：

 

现在setter方法基本没有问题了，那么在当我们要释放掉一个car对象的时候，必须也要释放它里面的_engine的引用，所以，要重写car的dealloc方法。

 

[plain] view plaincopy
 
  1. -(void)dealloc  
  2. {  
  3.     [_engine release]; //在释放car的时候，释放掉它对engine的引用  
  4.     [super dealloc];  
  5. }  


这还不是最好的释放的方法，下面的方法更好

 

 

[plain] view plaincopy
 
  1. -(void)dealloc  
  2. {  
  3.     [_engine setEngine:nil]; //在释放car的时候，对setEngine设置为nil，它不仅会release掉，并且指向nil，即使误操作调用也不会出错。  
  4.     [super dealloc];  
  5. }  



 

所以，综上所述，在setter方法中的最终写法是

 

[plain] view plaincopy
 
  1. <span style="color:#CC66CC;">-(void)setEngine:(Engine*) engine  
  2. {  
  3.    if(_engine!=engine){//判断是否重复设置  
  4.            [_engine release];//在设置之前，先release，那么在设置的时候，就会自动将前面的一个引用release掉  
  5.            _engine=[engine retain];//多了一个引用，retainCount+1  
  6.       }  
  7.  }</span>  


然后在dealloc方法中写法是：

 

 

[plain] view plaincopy
 
  1. <span style="color:#CC66CC;">-(void)dealloc  
  2. {  
  3.     [_engine setEngine:nil]; //在释放car的时候，对setEngine设置为nil，它不仅会release掉，并且指向nil，即使误操作调用也不会出错。  
  4.     [super dealloc];  
  5. }</span>  

 

 

 

六、property中的setter语法关键字

在property属性中有三个关键字定义关于展开setter方法中的语法，assgin(缺省)，retain，copy。当然这三个关键字是互斥的。

1、assgin展开stter的写法

 

[plain] view plaincopy
 
  1. -(void)setEngine:(Engine*) engine  
  2. {  
  3.      _engine=engine;  
  4. }  

 

 

2、retain展开的写法

 

[plain] view plaincopy
 
  1. -(void)setEngine:(Engine*) engine  
  2. {  
  3.    if(_engine!=engine){//判断是否重复设置  
  4.            [_engine release];//在设置之前，先release，那么在设置的时候，就会自动将前面的一个引用release掉  
  5.            _engine=[engine retain];//多了一个引用，retainCount+1  
  6.       }  
  7.  }  

 

3、copy展开的写法

 

[plain] view plaincopy
 
  1. -(void)setEngine:(Engine*) engine  
  2. {  
  3.    if(_engine!=engine){//判断是否重复设置  
  4.            [_engine release];//在设置之前，先release，那么在设置的时候，就会自动将前面的一个引用release掉  
  5.            _engine=[engine copy];//多了一个引用，retainCount+1  
  6.       }  
  7.  }  

 

对于copy属性有一点要主要，被定义有copy属性的对象必须要符合NSCopying协议，并且你还必须实现了-(id)copyWithZone:(NSZone*)zone该方法。

 

 

可以看到，使用retain和我们上面举得例子完全相同，所以我们可以使用property和它的retain代替之前的写法。

 Objective-C的内存管理（一）黄金法则的理解

Objective-C的内存管理（一）黄金法则的理解


联系
我们