黑马程序员——Objective-C学习笔记(六)：内存管理

——- android培训、IOS培训、期待与您交流！ ———-

引用计数

引用计数(reference counting),也叫做保留计数(retain counting)。对象都用一个与之相关联的整数，被称作引用计数器。当对象被访问时，该对象的保留计数器值加1。当访问结束时，对象的保留计数器值减1.当保留计数器的值为0时，表示不再需用该对象了，该对象将被摧毁，其占用的内存将被系统回收。

当使用alloc、new方法或通过copy消息创建一个对象时，对象的保留计数器被设置为1。要增加对象的保留计数器值，可以给对象发送一条retain消息。要减少的话，则发送一条release消息。

当一个对象因为保留计数器归0而即将被销毁时，Objective-C会自动向对象发送一条dealloc消息。可以在自己的对象中重写dealloc方法，这样就能释放掉已经分配的相关资源。不要直接调用dealloc方法，Objective-C会在需要销毁对象时自动调用。

要获得保留计数器当前的值，可以发送retainCount消息。retain方法返回一个id类型的值。这样可以在接收其它消息的同时进行retain调用。例如：[[car retain] setTire: tire atIndex: 2];表示要求car对象将其保留计数器的值加1并执行setTire操作。

例子：

//一个RetainTracker类对象，在初始化和销毁时调用了NSLog()函数
@interface RetainTracker: NSObject
@end // RetainTracker

@implementation Retaintracker
- (id) int
{
    if (self == [super init])
    {
        NSLog(@"init: Retain count of %d.", [self retianCount]);
    }
    return (self);
} // init

- (void) dealloc
{
    NSLog (@"dealloc called.");
    [super dealloc];
} // dealoc
@end // RetainTracker

当对象的保留计数器的值归0时，将自动发送dealloc消息(dealloc方法也会被调用)。

// 创建一个新的RetainTracker类的对象
// 并间接调用由RetainTracker类定义的两个方法
int main(int argc,const char *argv[])
{
    RetainTracker *tracker = [RetainTracker new];
    // count: 1

    [tracker retain]; // count: 2
    NSLog(@"%d",[tracker retainCount]);

    [tracker retain]; // count: 3
    NSLog(@"%d",[tracker retainCount]);

    [tracker release]; // count: 2
    NSLog(@"%d",[reacker retainCount]);

    [tracker release]; // count: 1
    NSLog(@"%d",[reacker retainCount]);

    [tracker retain]; // count: 2
    NSLog(@"%d",[tracker retainCount]);

    [tracker release]; // count: 1
    NSLog(@"%d",[reacker retainCount]);

    [tracker release]; // count: 0, dealloc it
    return 0;
} // main

对象所有权

如果一个一个对象内有指向其它对象的实例变量，则称该对象拥有这些对象。

当多个实体拥有特定变量时，对象的所有权关系就更加复杂了。比如前例Car类中的变量engine的存取方法：
- (void) setEngine: (Engine *) newEngine;

及如何在main()函数中调用该方法 ：

Engine *engine = [Engine new];
[car setEngine: engine];

哪个实体拥有engine对象？ main()还是Car类？哪个实体负责确保释放engine对象？
办法是让Car类保留engine对象，将engine对象的保留计数器的值增加到2.这是因为Car类和main()函数这两个实体都在使用engine对象。Car类应该在setEngine: 方法中保留engine对象，而main()函数负责释放engine对象。然后当Car类完成其任务时再释放engine对象。

访问方法中的保留和释放

setEngine: 的内存管理方法：

- (void) setEngine: (Engine *) newEngine
{
    [newEngine retain];
    [engine release];
    engine = newEngine;
} // setEngine

如果首先保留新的engine对象，即使newEngine与engine是同一个对象，保留计数器的值也将先增加，然后立即减少。由于没有归0，engine对象以外的未被销毁，这样就不会引发错误了。

自动释放

NSObject类提供一个叫做autorelease的方法：
- (id) autorelease;

该方法预先设定一条绘制未来某个时间发送的release消息，其返回值是接收这条消息的对象。当给一个对象发送autorelease消息时，实际上是将该对象添加到自动释放池中。当自动释放池被销毁时，会向该池中的所有对象发送release消息。

例子：

- (NSString *) description
{
    NSString *description;
    description = [[NSString alloc] ininWithFormat: @"%d years old", 4];
    return ([description autorelease]);
} // description

// 调用

NSLog (@"%@", [someObject description]);

description方法首先创建一个新的字符串对象，然后自动释放该对象，最后将其返回给NSLog()函数。由于description方法中的字符串对象是自动释放的，该对象暂时被放入了当前活动的自动释放池中，等到调用NSLog()函数的代码运行结束以后，自动释放池会被自动销毁。

自动释放池的销毁

有两种方法可以创建一个自动释放池。

• 通过@autoreleasepool关键字

• 通过NSAutoreleasePool关键字

  在Foundation库工具集中，创建和销毁自动释放池已经由@autorelease关键字完成。当使用@autorelease{}时，所有在花括号里的代码都会被放入这个新池子里。

  注意： 任何在花括号里定义的变量在括号外就无法使用了。

第二种更加明确的方法就是使用NSAutoreleasPool对象。使用这种对象，创建和释放NSAutoreleasePool对象之间的代码就会使用这个新的池子。

NSAutoreleasePool *pool;
pool = [NSAutoreleasePool new];
~
[pool release];

创建一个自动释放池后，该池就会自动成为活动的池子。释放该池后，其保留计数器的值归0，然后该池被销毁。在销毁的过程中，该池将释放其包含的所有对象。

自动释放池的工作流程

一个展示自动释放池工作流程的例子：

int main (int argc, const char *argv[])
{
// 创建自动释放池
    NSAutoreleasePool *pool;
    pool = [[NSAutoreleasePool alloc] init];

// 创建一个新的tracker对象，因为在创建时接收了一条new消息，其保留计数器的值为1
    RetainTracker *tracker;
    tracker = [RetainTracker new]; // count: 1

// 保留该对象，其保留计数器的值增加为2
    [tracker retain]; // count: 2

// 该吊销被自动释放，但是其保留计数器的值保持不变，依旧为2。
// 之前创建的自动释放池中现在有一个引用指向了该对象。
// 当自动释放池被销毁时，将向tracker对象发送一条release消息。
    [tracker autorelease]; // count: still 2

// 释放该对象以抵消之前对它执行的保留操作。该对象的保留计数器的值仍然大于0，仍处于活动状态。
    [tracker release]; // count 1

// 销毁自动释放池
    NSLog(@"releasing pool"); 
    [pool release]; // get nuked, sends release to reacker

// @autoreleasepool 效果相同，不过不需要分配或销毁自动释放池
    @autoreleasepool
    {
        RetainTracker *tracker2;
        tracker2 = [RetainTracker new]; // count: 1
        [tracker2 retain]; // count: 2
        [tracker2 autorelease]; // count: still 2
        [tracker2 release]; // count: 1

        NSLog(@"auto releasing pool");
    }

    return 0;
} // main

Cocoa的内存管理规则

• 当使用new、alloc或copy方法创建一个对象时，该对象的保留计数器的值为1.当不再使用该对象时，应该向该对象发送一条release或autorelease消息。这样，该对象将在其使用寿命结束时被销毁。

• 当通过其它方法获得一个对象时，假设该对象的保留计数器的值为1，而且已经被设置为自动释放，那么不需要执行任何操作来确保该对象得到清理。如果打算在一段时间内拥有该对象，则需要保留它并确保在操作完成是释放它。

• 如果保留了某个对象，就需要释放或自动释放该对象。必须保持retain方法和release方法的使用次数相等。

就这三条规则。

临时对象

如果正在代码中使用某对象，但是并未打算长期拥有该对象。如果用new、alloc或copy方法获得的这个对象，就需要安排好该对象的内存释放，通常使用release消息来实现。

NSMutableArray *array;
array = [[NSMutableArray alloc] init]; // count: 1
// use array
[array release]; //count: 0

如果使用其它方法获得一个对象，比如arrayWithCapacity: 方法，则不需要关心如何销毁该对象。

NSMutableArray *array;
array = [NSMutableArray arrayWithCapaciy: 17];
// count: 1,autoreleased
// use array

arrayWithCapacity: 方法与alloc、new、copy这三个方法不同，因此可以假设该对象被返回时保留计数器的值为1且已经被设置为自动释放。

拥有对象

在多段代码中一直拥有某个对象。典型的方法是，把它们加入到NSArray或NDictionary等集合中，作为其它对象的实例变量来使用。
如果使用new、alloc或copy方法获得一个对象，则不需要执行任何其它操作。该对象的保留计数器的值为1，因此它将一直存在，只需要确保在拥有该对象的dealloc方法中释放它。

- (void) dostuff
{
    // flonkArray is an instance variable
    flonkArray = [NSMutableArray new]; // count: 1
} // doStuff

- (void) dealloc
{
    [flonkArray release]; // count: 0
    [super dealloc];
} // dealloc

当使用自动释放对象时，重写如下：

- (void) dostuff
{
    // flonkArray is an instance variable
    flonkArray = [NSMutableArray arrayWithCapacity: 17];
    // count: 1, autoreleased
    [flonkArray retain]; // count: 2, 1 autorelease
} // dostuff

- (void) dealloc
{
    [flonkArray release]; // count: 0
    [super dealloc];
} // dealloc

自动释放池被清理的时间是完全确定的： 要么在代码中手动销毁，要么是使用AppKit时在事件循环结束时销毁。不必担心程序会随机的销毁自动释放池每页不必保留使用的每一个对象，因为在调用函数的过程中自动释放池不回被销毁。

异常

异常就是意外事件，比如数组溢出，因为程序不知道怎么处理就会扰乱程序流程。当发生这种情况时，程序可以创建一个异常对象，让他在运行时系统中计算出接下来该怎么做。Cocoa中使用NSException类来表示异常。Cocoa要求所有的异常必须是NSExcepton类型的异常。

与异常有关的关键字

@try: 定义用来测试的代码块以决定是否要 抛出异常。

@catch(): 定义用来处理已抛出异常的代码块。接收一个参数，通常是NSException类型，但也可以是其它类型。

@finally(): 定义无论是否有抛出异常都会执行代码块，这段代码总会执行。

@throw: 抛出异常。

通常会在一个结构中同时使用@try、@catch、@finally ，形如：

@try
{
    //code you want to execute that might throw an exception.
}
@catch(NSException *exception)
{
    //code to execute that handles exception
}
@finally
{
    //code that will always be executed.Typically for cleanup.
}

捕捉不同类型的异常

可以根据需要处理的异常类型使用多个@catch代码块。处理代码按照从具体到抽象的顺序排序，并在最后使用一个通用的处理代码。

@try {}
@catch(MyCustomException *custom) {}
@catch(NSException *exception) {}
@catch(id value) {}
@finally {}

抛出异常

当程序检测到了异常，就必须向处理它的代码块报告这个异常。
程序会创建一个NSException实例来抛出异常，并会使用以下两种技术之一：

• 使用”@throw异常名; “语句来抛出异常；

• 向某个NSException对象发送raise消息。

比如，创建一个异常：

NSException *theException = [NSException exceptionWithName: ...];

要抛出这个异常：

@throw theException;

或

[theException raise];

两种方法都行，但不要两种都使用。两种方法的区别是raise只对NSException对象有效，而@throw也可以用在其它对象上。
通常会在异常处理代码中抛出异常。代码可以通过再发送一次raise消息或使用@throw关键字来通知异常。

@try
{
    NSException *e = ...;
    @throw e;
}
@catch (NSException *e)
{
    @throw; // rethrows e.
}

在@catch异常处理代码中，可以重复抛出异常而无需指定异常对象。

与当前@catch异常处理代码相关的@finally代码块会在@throw引发下一个异常处理调用之前执行代码，因为@finally是在@throw发送之前调用的。
Objective-C的异常机制与C++的异常机制兼容。

异常的内存管理

如果代码中有异常，内存管理执行起来会比较复杂：

- (void) mySimpleMethod
{
    NSDictionary *dictionary = [[NSDictionary alloc] initWith...];
[self procssDictionary: dictionary];    
[dictionary release];
}

假设processDictionary抛出一个异常。程序从这个方法中跳出并寻找异常处理代码。由于方法已经退出了，所以字典对象并没有被释放，于是就会出现内存泄漏。
简单的方法就是使用@try和@finally代码块，因为@finally总是会执行的，所以它可以在里面进行清理工作。

- (void) mySimpleMethod
{
    NSDictionary *dictionary = [[NSDictionary alloc] initWith...];
    @try
    {
        [self processDictionary: dictionary];
    }
    @finally
    {
        [dictionary release];
    }
}

异常和自动释放池

因为不知道该什么时候释放异常，所以异常几乎总是作为自动释放对象而创建。当自动释放池销毁了之后，自动释放池中所有的对象也会被销毁，包括异常。

- (void) myMethod
{
    NSAutoreleasepool *pool = [[NSAutoreleasePool alloc] init];
    NSDictionary *myDictionary = [[NSDictionary alloc] iniWithObjecsAndKeys: @"asdfads",nil];
    @try
    {
        [self processDictionary: myDictionary];
    }
    @catch (NSException *e)
    {
        @throw;
    }
    @finally
    {
        [pool release];
    }
}

@finally代码块在异常重新抛出之前执行了导致本地pool的释放早于异常通知。

- (void) myMethod
{
    id saveException = nil;
    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
    NSDictionary *myDictionary = [[NSDictionary alloc] initWithObjectsAndKeys: @"adadads",nil];
    @try
    {
        [self processDictionary: myDictionary];
    }
    @catch (NSException *e)
    {
        saveException = [e retain];
        @throw;
    }
    @finally
    {
        [pool release];
        [saveException autorelease];
    }
}

通过使用retain方法在当前池中保留了异常。当池被释放时，由于早已保存了一个异常指针，，它会同当前池一起释放。