Objective-C 内存管理

声明

欢迎转载，但是请尊重作者劳动成果，转载请保留此框内声明，谢谢。
文章出处：http://blog.csdn.net/iukey

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

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

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

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

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

[ pool drain];

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

[ pool release ];

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

如果你使用手动管理内存，请往下看：

一、申请内存（alloc）

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

   //str1 是autorelease的，会自动释放
    NSString* str1 = [NSString string];
    //str2需要手动释放
    NSString* str2 = [[NSString alloc]init];
    //str2 使用完后
    [str2 release];

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

二、释放内存（dealloc）

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

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

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

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

三、引用计数器（retainCout）

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

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

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

 stu =nil;

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

int main(int argc, char *argv[]){
    NSAutoreleasePool* pool = [[NSAutoreleasePool alloc]init];
    
    NSNumber* int1 = [NSNumber numberWithInt:222];
    NSNumber *int2;
    NSMutableArray* arr1 = [NSMutableArray array];
    NSLog(@"初始化以后：int1(retainCount):%lu int2(retainCount):%lu",(unsigned long)[int1 retainCount],(unsigned long)[int2 retainCount]);
    
    [arr1 addObject:int1];
    NSLog(@"将int1添加到数组以后：int1(retainCount):%lu int2(retainCount):%lu",(unsigned long)[int1 retainCount],(unsigned long)[int2 retainCount]);
    
    int2 = int1;
    NSLog(@"进行赋值操作以后：int1(retainCount):%lu int2(retainCount):%lu",(unsigned long)[int1 retainCount],(unsigned long)[int2 retainCount]);
    
    [int1 retain];
    NSLog(@"int1 retain以后：int1(retainCount):%lu int2(retainCount):%lu",(unsigned long)[int1 retainCount],(unsigned long)[int2 retainCount]);
    
    [int1 release];
    NSLog(@"int1 release以后：int1(retainCount):%lu int2(retainCount):%lu",(unsigned long)[int1 retainCount],(unsigned long)[int2 retainCount]);
    
    [arr1 removeObject:0];
    NSLog(@"从数组中删除int1以后：int1(retainCount):%lu int2(retainCount):%lu",(unsigned long)[int1 retainCount],(unsigned long)[int2 retainCount]);
    
    [pool drain];
    return 0;
}

程序结果：

初始化以后：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创建的对象：

 NSNumber* num1 = [[NSNumber alloc]initWithFloat:1.80];
    NSNumber* num2 = [NSNumber numberWithFloat:145.0];
    //我们只需要释放num1，不用释放num2
    [num1 release];

再看下面的例子：

int main(int argc, char *argv[]){
    NSAutoreleasePool* pool = [[NSAutoreleasePool alloc]init];
    
    NSString* str1 = @"LiuWei";
    NSString* str2 = [NSString stringWithString:@"IUKEY"];
    NSMutableString* str3 = [NSMutableString stringWithString:@"MasterLiuWei"];
    NSMutableArray* arr1 = [NSMutableArray array];
    //初始化以后 各个retainCount：str1:fffffffffffffff str2:fffffffffffffff str3:1
    
    [arr1 addObject:str1];
    [arr1 addObject:str2];
    [arr1 addObject:str3];
    //将字符串添加到数组以后，各个retainCount：str1:fffffffffffffff str2:fffffffffffffff str3:2
  
    [str1 retain];
    [str2 retain];
    [str3 retain];
    //执行retain以后，各个retainCount：str1:fffffffffffffff str2:fffffffffffffff str3:3
    
    [str3 release];
    //执行release以后，各个retainCount：str1:fffffffffffffff str2:fffffffffffffff str3:2
    
    [pool drain];
    return 0;
}

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

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

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）：

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

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

- (void) setScore:(NSNumber*)inputScore{
    [score autorelease];
    score = [inputScore retain];
}

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

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

  NSNumber* value1 = [[NSNumber alloc]initWithFloat:180.0];
    [self setScore:value1];
    
    NSNumber* value2 = [NSNumber numberWithFloat:72.5];
    [self setScore:value2];
    [value1 release];

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

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

#import <Foundation/Foundation.h>

@interface Student : NSObject{
    NSString* name;
}
-(void)setName:(NSString*)s;
-(NSString*)name;
@end

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

#import "Student.h"

@implementation Student
-(void)setName:(NSString *)s{
    name =s;
}

-(NSString*)name{
    return name;
}
@end

下面是测试代码：

NSMutableString* str1 = [NSMutableString stringWithString:@"LiuWei"];
    Student* stu = [[Student alloc]init];
    
    NSLog(@"str1的引用计数器：%x",[str1 retainCount]);
    
    [stu setName:str1];
    NSLog(@"str1的引用计数器：%x",[str1 retainCount]);
    [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 还能够正常使用。

#import "Student.h"

@implementation Student
-(void)setName:(NSString *)s{
    name =s;
    [name retain];
}

-(NSString*)name{
    return name;
}
@end

再来测试：

NSMutableString* str1 = [NSMutableString stringWithString:@"LiuWei"];
    Student* stu = [[Student alloc]init];
    
    NSLog(@"str1的引用计数器：%x",[str1 retainCount]);
    
    [stu setName:str1];
    NSLog(@"str1的引用计数器：%x",[str1 retainCount]);
    [stu release];
    NSLog(@"str1的引用计数器：%x",[str1 retainCount]);

测试结果：

str1 的引用计数器：1

str1 的引用计数器：2

str1 的引用计数器：1

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

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

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

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

//  Student.h

#import <Foundation/Foundation.h>

@interface Student : NSObject{
    NSString* name;
}
-(void)setName:(NSString*)s;
-(NSString*)name;
- (void)dealloc;
@end

//  Student.m

#import "Student.h"

@implementation Student
-(void)setName:(NSString *)s{
    [name autorelease];
    name = [s retain];
}

-(NSString*)name{
    return name;
}

- (void)dealloc{
    [name release];
    [super dealloc];
}
@end

测试代码：

 NSMutableString* str1 = [NSMutableString stringWithString:@"LiuWei"];
    Student* stu = [[Student alloc]init];
    
    NSLog(@"str1的引用计数器：%x",[str1 retainCount]);
    
    [stu setName:str1];
    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。比如：

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

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

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

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

int main(int argc, char *argv[])
{
    NSAutoreleasePool* pool = [[NSAutoreleasePool alloc]init];
    Student* stu =[[Student alloc]init];//1
    NSLog(@"%x",[stu retainCount]);
    
    [pool drain];
    NSLog(@"%x",[stu retainCount]);//1
    
    pool =[[NSAutoreleasePool alloc]init];
    [stu autorelease];
    NSLog(@"%x",[stu retainCount]);//1
    
    [stu retain];
    NSLog(@"%x",[stu retainCount]);//2
    
    [pool drain];
    NSLog(@"%x",[stu retainCount]);//1
    [stu release];
    
    return 0;
}

六、内存泄漏

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

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

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

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

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

七、copy、nonatomic

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

@property(nonatomic,copy)NSString* name;

这个语句就等价于：

-(void)setName:(NSString *)s{
    if (s != name) {
        [name release];
        name = [s copy];
    }
}

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

-(void)setName:(NSString *)s{
    name = s;
}

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

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