`
dcj3sjt126com
  • 浏览: 1818544 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

Objective-C 内存管理

    博客分类:
  • IOS
 
阅读更多
声明
欢迎转载,但是请尊重作者劳动成果,转载请保留此框内声明,谢谢。
文章出处:http://blog.csdn.net/iukey

 

 

 

 

大概是因为 Objective-C 是 C的超集,所以Objective-C 也使用alloc来申请内存,不同的是C调用free来直接释放内存,而Objective-C 不直接调用dealloc来释放内存。整个Objective-C 都使用对象的引用,而每个对象都有一个引用计数器。当计数器为0时,系统调用dealloc来释放内存。Objective-C 业提供了autorelease 属性,从而可以让系统自动释放对象所占有的内存。程序中可以设置一个自动释放池,系统使用这个池来跟踪对象。使用如下语句可以创建一个自动释放池:

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

在我们的程序入口处,xcode也帮我们建了一个自动释放池,而且把整个程序循环加了进去。

  1. int main(int argc, char *argv[])  
  2. {  
  3.     @autoreleasepool {//这个说实话我也没搞明白,不过我知道它创建了一个自动释放池,然后把我们的程序放到了这个池子里  
  4.         return UIApplicationMain(argc, argv, nil, NSStringFromClass([AppDelegate class]));  
  5.     }  
  6. }//先别管这个的具体意思,你只要知道xcode帮我们建了一个自动释放池,然后把整个程序放到了自动释放池里面。  

在这个 自动释放池建立之后,基础框架就自动将数组、字符串等对放到这个池中。当下面语句被执行时,池中的对象就被自动释放:

  1. [ pool drain];  

总之,一个对象被标识为自动释放对象,那么就会被加到自动释放池中。除了使用drain来释放池中的对象外,在自动释放池本身被释放时,池中的所有对象也会被释放。自动释放池语句如下:

  1. [ pool release ];  

之前是没有ARC(Automatic Reference Counting)功能的,现在有了,我想ARC 主要是为从Java转过来的程序员而设计的吧,因为这个差不多相当于Java里面的自动垃圾收集器吧。从C/C++转过来的程序员大多数还是愿意手动去释放的,因为他们不大相信自动释放的效率,还有就是他们喜欢掌控一切的感觉,比如我。如果你要开启,在创建工程的时候请勾选上这个选项:

如果你使用手动管理内存,请往下看:

一、申请内存(alloc)

当使用 alloc 创建了一个对象时,需要在用完这个对象后释放(release)它,你不需要自己去释放一个被设置为自动释放(autorelease)的对象,如果你真的这么干了,对不起,程序会崩溃。

  1. //str1 是autorelease的,会自动释放  
  2.  NSString* str1 = [NSString string];  
  3.  //str2需要手动释放  
  4.  NSString* str2 = [[NSString alloc]init];  
  5.  //str2 使用完后  
  6.  [str2 release];  

为便于理解,你可以理解成autorelease型的对象会在该释放他的时候自动释放。

 

二、释放内存(dealloc)

当一个对象从内存上删除之前,系统就会调用dealloc方法,这是释放对象成员变量的最好时机。比如:

  1. - (void)dealloc{  
  2.     [_window release];  
  3.     [super dealloc];  
  4. }  

上例中,先调用release释放了成员变量_window所占用的内存。相对而言,用标准的release比autorelease更快一点。最后一行[ super dealloc ]; 非常重要,必须调用这个方法让父类清楚它自己,否则会造成内存泄漏。

 

在ARC模式下,dealloc 不会被调用到,取而代之的是,需要实现finalize方法 。

三、引用计数器(retainCout)

整个Objective-C都使用对象引用,而每个对象有一个引用计数器。当时用alooc(或copy)方法创建一个对象时。其计数器的值为 1 。当计数器为 0 时,系统自动调用 dealloc方法来释放内存中的对象。比如:

  1. STU *stu = [[STU alloc]init];//计数器为1  
  2.     [stu retain];//计数器为2  
  3.     [stu release];//计数器为1  
  4.     [stu release];//计数器为0,系统自动调用dealloc方法  
  5.     //释放之后,如果调用该对象的任何一个方法,程序就会异常终止  
  6.     [stu goHiking];//崩溃  

为了防止上述的异常崩溃出现,可以在最后一个release之后加一句:

  1. stu =nil;  

上述语句将该对象置为nil。在这之后,任何调用该member的方法都返回nil,而不是异常终止。再来看下面的例子:

  1. int main(int argc, char *argv[]){  
  2.     NSAutoreleasePool* pool = [[NSAutoreleasePool alloc]init];  
  3.       
  4.     NSNumber* int1 = [NSNumber numberWithInt:222];  
  5.     NSNumber *int2;  
  6.     NSMutableArray* arr1 = [NSMutableArray array];  
  7.     NSLog(@"初始化以后:int1(retainCount):%lu int2(retainCount):%lu",(unsigned long)[int1 retainCount],(unsigned long)[int2 retainCount]);  
  8.       
  9.     [arr1 addObject:int1];  
  10.     NSLog(@"将int1添加到数组以后:int1(retainCount):%lu int2(retainCount):%lu",(unsigned long)[int1 retainCount],(unsigned long)[int2 retainCount]);  
  11.       
  12.     int2 = int1;  
  13.     NSLog(@"进行赋值操作以后:int1(retainCount):%lu int2(retainCount):%lu",(unsigned long)[int1 retainCount],(unsigned long)[int2 retainCount]);  
  14.       
  15.     [int1 retain];  
  16.     NSLog(@"int1 retain以后:int1(retainCount):%lu int2(retainCount):%lu",(unsigned long)[int1 retainCount],(unsigned long)[int2 retainCount]);  
  17.       
  18.     [int1 release];  
  19.     NSLog(@"int1 release以后:int1(retainCount):%lu int2(retainCount):%lu",(unsigned long)[int1 retainCount],(unsigned long)[int2 retainCount]);  
  20.       
  21.     [arr1 removeObject:0];  
  22.     NSLog(@"从数组中删除int1以后:int1(retainCount):%lu int2(retainCount):%lu",(unsigned long)[int1 retainCount],(unsigned long)[int2 retainCount]);  
  23.       
  24.     [pool drain];  
  25.     return 0;  
  26. }  

程序结果:

初始化以后:int1(retainCount):1 int2(retainCount):0

将int1添加到数组以后:int1(retainCount):2 int2(retainCount):0

进行赋值操作以后:int1(retainCount):2 int2(retainCount):2

int1 retain以后:int1(retainCount):3 int2(retainCount):3

int1 release以后:int1(retainCount):2 int2(retainCount):2

从数组中删除int1以后:int1(retainCount):1 int2(retainCount):1

基础框架所提供的一些方法也会增加对象的引用次数,比如,把对象添加到一个数组中的时候。

在上面的例子中,首先将NSNumber对象int1的值设置为整数222,我们定义了int2但是没有初始化。这时候打印引用计数器,会发现int1的计数器为1,int2的计数器为0。也就是说,只有真正创建了一个对象,并且正常初始化了之后,才会增加引用计数器。

随后使用addObject:方法将int1添加到数组arr1中,打印计数器,不难发现int1的计数器变为2,int2的计数器还是0。也就是说当对象添加到任何类型的集合中时,都会使改对象的有效引用增加。

接下来,将int1的值赋给int2,这时候的结果值得我们注意。int1与int2的引用计数器都是2了,这说明进行赋值操作并未使int1的计数器增加,但是int2的计数器变为了2。这是因为当把int1赋给int2的时候,并不是复制实际的对象,而是将该对象的内存地传递给了int2。也就是说这两个指针指向的是同一个对象。

然后我们向int1发送retain消息来增加引用计数,int2的引用计数器当然也随之增加咯。

然后向int1发送release消息,int1与int2的引用计数当然同时减 1 咯。

最后,从arr1中移除 int1 ,这样int1与int2的引用计数又同时减 1 。但是这时候对象并未真正释放,因为引用计数器 1,并不是0。如果要释放你还得 release一次。

Objective-C的内存管理系统基于引用计数。我们需要跟踪引用,以及在运行期内是否真的释放了内存。简单来说就是每次调用了alloc或者retain之后都需要调用release。

在程序中,你只在两种情况下跟踪一个对象:(1)本地变量(在一个方法里面临时使用,比如创建一个字符串)(2)成为一个类的成员变量只要掌握了跟踪者两种情况,并作出相应内存释放,你就基本掌握了Objective-C的内存管理。

三、字符串处理

如果使用alloc或者copy创建一个对象(比如字符串),那么在方法结束的时候需要release或者autorelease这个对象。假如我们是通过别的方式创建的,就可以不管。在下面的粒子中,只需要release那些使用alloc创建的对象:

  1. NSNumber* num1 = [[NSNumber alloc]initWithFloat:1.80];  
  2.    NSNumber* num2 = [NSNumber numberWithFloat:145.0];  
  3.    //我们只需要释放num1,不用释放num2  
  4.    [num1 release];  

再看下面的例子:

  1. int main(int argc, char *argv[]){  
  2.     NSAutoreleasePool* pool = [[NSAutoreleasePool alloc]init];  
  3.       
  4.     NSString* str1 = @"LiuWei";  
  5.     NSString* str2 = [NSString stringWithString:@"IUKEY"];  
  6.     NSMutableString* str3 = [NSMutableString stringWithString:@"MasterLiuWei"];  
  7.     NSMutableArray* arr1 = [NSMutableArray array];  
  8.     //初始化以后 各个retainCount:str1:fffffffffffffff str2:fffffffffffffff str3:1  
  9.       
  10.     [arr1 addObject:str1];  
  11.     [arr1 addObject:str2];  
  12.     [arr1 addObject:str3];  
  13.     //将字符串添加到数组以后,各个retainCount:str1:fffffffffffffff str2:fffffffffffffff str3:2  
  14.     
  15.     [str1 retain];  
  16.     [str2 retain];  
  17.     [str3 retain];  
  18.     //执行retain以后,各个retainCount:str1:fffffffffffffff str2:fffffffffffffff str3:3  
  19.       
  20.     [str3 release];  
  21.     //执行release以后,各个retainCount:str1:fffffffffffffff str2:fffffffffffffff str3:2  
  22.       
  23.     [pool drain];  
  24.     return 0;  
  25. }  

你可能会对结果产生疑问,为什么是fffffffffffffff 呢?在程序中,NSString 的对象 str1 赋值为静态的字符串@"welcome"。字符串常量的内存分配方式和其他的对象不同,这种方式没有引用计数机制,因此永远不能释放这些对象。当向 str1 发送消息 retainCount 的时候,它返回fffffffffffffff ,即最大的无符号整数。注意:这同样适用于用字符串常量初始化那些不可变的字符串对象。

 

值得注意的是下面的语句:

  1. NSMutableString* str3 = [NSMutableString stringWithString:@"MasterLiuWei"];  

这条语句使用字符串常量来初始化一个可变字符串对象,通过 stringWithString: 方法进行。由于可变字符串的至可能在程序运行过程中发生变化。但是字符串常量是无法改变的,所以系统拷贝这个字符串常量到 str3 上来完成初始化。因此可变字符串对象拥有了引用计数。

当我们使用stringWithString:  方法创建不可变字符串对象时,这个对象其实被添加到了自动释放池。通过array 方法所创建的对象arr1 对象也被添加到了自动释放池。

程序中的代码块将这些字符串添加到数组中,冰箱这给谢对象发送retain 消息。从程序的结果可以看出,这些操作改变了他们的引用技术。

在释放自动释放池之前,str3已经被释放了一次。所以 str3 的引用计数变为2。随后,自动释放池的释放使得这些对想的引用技术减为 0 ,这使得他们被释放。当释放自动释放池的时候,池中的每一个对象都会收到一条 release 消息(收到的条数等于当时发送autorelease消息的条数)。由于在使用 stringWithString: 方法所创建的字符串对象 str3 时,系统将他添加到自动释放池,也就是说调用了 autorelease 方法,所以,当自动释放池被释放(drain)时,str3会收到一条  release消息,这将导致他的引用计数减为1。当自动释放池中的数组被释放的时候,数组中的每个元素也将被释放,所以数组中的每个元素都将收到一条release'消息,这将使str3的引用计数变为0 。系统随之将调用str3的dealloc方法将str3释放。

注意:如果我们过度释放,程序将异常终止。

四、类成员变量

在大多数情况下,一个成员变量的setter方法应该仅仅 aytorelease/release 旧的对象,然后 retain/copy 新的对象。我们只需要在 dealloc的时候调用release就好了。所以真正需要管理的就是方法内部的局部变量的引用。比如,设置字符串(使用copy):

  1. - (void)setName:(NSString*)newName{  
  2.     if (name != newName) {  
  3.         [name release];  
  4.         name = [newName copy];//name 的计数器为1  
  5.     }  
  6. }  

下面是使用retain管理成员对象的另一个例子:

  1. - (void) setScore:(NSNumber*)inputScore{  
  2.     [score autorelease];  
  3.     score = [inputScore retain];  
  4. }  
  1. - (void)dealloc{  
  2.     [score release];  
  3.     [super dealloc];  
  4. }  

下面是使用本地对象去设置一个成员变量的例子:

  1. NSNumber* value1 = [[NSNumber alloc]initWithFloat:180.0];  
  2.   [self setScore:value1];  
  3.     
  4.   NSNumber* value2 = [NSNumber numberWithFloat:72.5];  
  5.   [self setScore:value2];  
  6.   [value1 release];  

下面我来分析一下几种成员变量的处理方法。

 

首先定义一个类,它只包含NSString类型的name属性,并手动书写了这个属性的存取方法。

  1. #import <Foundation/Foundation.h>  
  2.   
  3. @interface Student : NSObject{  
  4.     NSString* name;  
  5. }  
  6. -(void)setName:(NSString*)s;  
  7. -(NSString*)name;  
  8. @end  

在下面的方法实现文件中,我们直接把setName: 方法中的形参 s 的值赋给 name 属性,并没有做其他的操作。

  1. #import "Student.h"  
  2.   
  3. @implementation Student  
  4. -(void)setName:(NSString *)s{  
  5.     name =s;  
  6. }  
  7.   
  8. -(NSString*)name{  
  9.     return name;  
  10. }  
  11. @end  

下面是测试代码:

  1. NSMutableString* str1 = [NSMutableString stringWithString:@"LiuWei"];  
  2.     Student* stu = [[Student alloc]init];  
  3.       
  4.     NSLog(@"str1的引用计数器:%x",[str1 retainCount]);  
  5.       
  6.     [stu setName:str1];  
  7.     NSLog(@"str1的引用计数器:%x",[str1 retainCount]);  
  8.     [stu release];  

测试结果:

 

str1 的引用计数器:1

str1 的引用计数器:1

程序首先为Student类创建了对象stu ,然后调用这个对象的setName 方法,将name的值设置为  str1的值(str1 和name 这两个指针指向的是同一块内存空间)。这种做法有一个问题,在设置完毕以后,如果不需要str1对象并将其释放,那么str1的 引用计数器变为0。毫无疑问,name的引用计数器也将变为0 ,存储在那么中的值则变为无效的。

由于str1是用 NSMutableString stringWithString: 方法创建的,该对象也被自动添加到自动释放池之中(虽然没有显式将对象添加到 自动释放池中)。因此,在自动释放池释放的时候,str1 也会被释放,这时,任何str1所指向的对象的访问都将是无效的。

下面我们来看第二种写法。接口文件未改动,所以参看上面的接口代码。在实现文件中我们执行了 [ name retain] 方法,这样会使 name 的引用计数器增加 1 ,从而在str1 释放的时候,name 还能够正常使用。

  1. #import "Student.h"  
  2.   
  3. @implementation Student  
  4. -(void)setName:(NSString *)s{  
  5.     name =s;  
  6.     [name retain];  
  7. }  
  8.   
  9. -(NSString*)name{  
  10.     return name;  
  11. }  
  12. @end  

再来测试:

  1. NSMutableString* str1 = [NSMutableString stringWithString:@"LiuWei"];  
  2.     Student* stu = [[Student alloc]init];  
  3.       
  4.     NSLog(@"str1的引用计数器:%x",[str1 retainCount]);  
  5.       
  6.     [stu setName:str1];  
  7.     NSLog(@"str1的引用计数器:%x",[str1 retainCount]);  
  8.     [stu release];  
  9.     NSLog(@"str1的引用计数器:%x",[str1 retainCount]);  

 

测试结果:

 

str1 的引用计数器:1

str1 的引用计数器:2

str1 的引用计数器:1

根据结果,在调用 setName: 之后,str1的引用计数器变为2 ,上一个程序中所产生的问题得以解决。接着就在程序中执行了 [str1 release] 方法,使得 str1 的引用计数器减少为 1,这时候对name的引用依然有效。

由于程序使用了alloc方法创建 Student 类的对象,就需要负责将这个对象释放掉。我们可以手动释放,也可以调用 它的autorelease 方法,将其添加到自动释放池中。在这之前我们都能正常使用这个对象。

但是这样的写法还是存在一些问题,setName: 方法保持了作为参数传入的字符串对象,但是这个对象什么时候释放呢?当多次 更改name 值的时候,原来的那些值会怎样?应该释放他们所占用的内存么?

下面来看最终的处理方法:

  1. //  Student.h  
  2.   
  3. #import <Foundation/Foundation.h>  
  4.   
  5. @interface Student : NSObject{  
  6.     NSString* name;  
  7. }  
  8. -(void)setName:(NSString*)s;  
  9. -(NSString*)name;  
  10. - (void)dealloc;  
  11. @end  
  1. //  Student.m  
  2.   
  3. #import "Student.h"  
  4.   
  5. @implementation Student  
  6. -(void)setName:(NSString *)s{  
  7.     [name autorelease];  
  8.     name = [s retain];  
  9. }  
  10.   
  11. -(NSString*)name{  
  12.     return name;  
  13. }  
  14.   
  15. - (void)dealloc{  
  16.     [name release];  
  17.     [super dealloc];  
  18. }  
  19. @end  

测试代码:

  1. NSMutableString* str1 = [NSMutableString stringWithString:@"LiuWei"];  
  2.    Student* stu = [[Student alloc]init];  
  3.      
  4.    NSLog(@"str1的引用计数器:%x",[str1 retainCount]);  
  5.      
  6.    [stu setName:str1];  
  7.    NSLog(@"str1的引用计数器:%x",[str1 retainCount]);  

测试结果:

 

 

str1 的引用计数器:1

str1 的引用计数器:2

通过上面的方法,不管name中当前存储的值是什么,我们在 setName: 方法中首先将其手动添加到自动释放池中,这也可以让其以后自动释放 name 。当程序中多次调用 setName: 方法时,这项操作将更加重要:每次存储新的值的时候,变量就得值将标记为自动释放,保持新的值到name中。

当系统释放一个对象时,系统自动调用dealloc 方法。对于保持(retain)的对象,或者使用alloc分配的对象,或者在方法中复制的对象,可以在dealloc方法中去释放它们。首先释放name变量,因为他是保持对象:然后调用父类的dealloc方法来释放Student 的对象。如果需要外部的字符串完全独立于设置方法的参数,可以在设置方法中声称字符串的全新副本,即使用copy选项。

五、自动释放( autorelease )池

 在代码中创建了一个字符串,如果需要返回这个字符串的话,那么需要使用 autorelease,而不是release。比如:

  1. - (NSString*)getStr{  
  2.     NSString* str;  
  3.     str = [[NSString alloc]initWithFormat:@"Result return "];  
  4.     //[ str release];  //不能释放,否则调用者无法获得返回值  
  5.     [str autorelease];//正确  
  6.     return str;  
  7. }  

通过使用autorelease,该对象就被放入自动释放池,系统自动跟踪每个对象的使用情况,并在

 

释放自动释放池时, 释放池中的所有对象

注意:autorelease 不是垃圾搜集(Garbage Collection)功能。在iPhone 操作系统上的Objective-C没有垃圾搜集功能。另外,你可以创建多个自动释放池。

  1. int main(int argc, char *argv[])  
  2. {  
  3.     NSAutoreleasePool* pool = [[NSAutoreleasePool alloc]init];  
  4.     Student* stu =[[Student alloc]init];//1  
  5.     NSLog(@"%x",[stu retainCount]);  
  6.       
  7.     [pool drain];  
  8.     NSLog(@"%x",[stu retainCount]);//1  
  9.       
  10.     pool =[[NSAutoreleasePool alloc]init];  
  11.     [stu autorelease];  
  12.     NSLog(@"%x",[stu retainCount]);//1  
  13.       
  14.     [stu retain];  
  15.     NSLog(@"%x",[stu retainCount]);//2  
  16.       
  17.     [pool drain];  
  18.     NSLog(@"%x",[stu retainCount]);//1  
  19.     [stu release];  
  20.       
  21.     return 0;  
  22. }  

 

六、内存泄漏

为了防止内存泄漏,并确保最有效地使用内存,应用程序应该只在需要时才装载数据。,比如,用户点击了某个按钮才显示相关数据。我们在前面讲了autorelease ,但是如果你的代码总是 autorelease,就没有内存泄漏了吗?问题在于autorelease 池释放的时机。每当执行应用程序时,系统自动创建 autorelease 池。系统并不是立即释放autorelease池中的对象,而是在一个run loop之后才释放,一般是微妙级别。在 autorelease 池中的对象本可以立即释放,但是系统很有可能过一段时间才释放他们,所以 使用release 可以更有效地释放内存。所以,我们应该尽量自己管理内存,不要太依赖 autorelease 。另外,一些系统对象使用 autorelease,如NSString。你可以 ziji管理内存的类,如NSMutableString,你可以创建自己的池。

下面是几个内存管理的基本原则:

1>如果使用 alloc(或者copy)方法创建一个对象,或者使用retain 保留一个对象,那么 ,都要自己释放对象。

2>在大多数情况下,申请内存的语句数量和释放内存的语句数量应该相等

3>尽量少使用内存,用完立即释放

七、copy、nonatomic

对于字符串类型的属性变量,我们经常使用下面类似的语句:

  1. @property(nonatomic,copy)NSString* name;  

这个语句就等价于:

  1. -(void)setName:(NSString *)s{  
  2.     if (s != name) {  
  3.         [name release];  
  4.         name = [s copy];  
  5.     }  
  6. }  

那么为什么要使用copy呢?如果直接使用下面的语句,结果将如何呢?

  1. -(void)setName:(NSString *)s{  
  2.     name = s;  
  3. }  

结果是name 和 s 都指向同一个对象。当在调用 setName: 方法之后,如果 s 的值被修改,这显然不是我们想要的结果。所以,使用copy 来拷贝 s 的值到name 上,其完成的功能就是调用一个alloc 方法来创建一个新的字符串对象 (initWithStringLs).

 

在多线程中,两个或多个线程可能在同一时间执行同一代码。为了防止这种现象发生,开发人员可以使用互斥锁。nonatomic 的意思是不需要使用互斥锁, atomic 是使用互斥锁。缺省 是atomic 。 如果你的程序并没有多线程,可以设置为 nonatomic 以节省资源。

分享到:
评论

相关推荐

Global site tag (gtag.js) - Google Analytics