Iphone开发基础篇（五）-ObjectC之内存管理

首先简单阐述一下Objective-C内存管理：
1.当你使用new,alloc和copy方法创建一个对象时,该对象的保留计数器值为1.当你不再使用该对象时,你要负责向该对象发送一条release或autorelease消息.这样,该对象将在使用寿命结束时被销毁.
2.当你通过任何其他方法获得一个对象时,则假设该对象的保留计数器值为1,而且已经被设置为自动释放,你不需要执行任何操作来确保该对象被清理.如果你打算在一段时间内拥有该对象,则需要保留它并确保在操作完成时释放它.
3.如果你保留了某个对象,你需要(最终)释放或自动释放该对象.必须保持retain方法和release方法的使用次数相等.

面试题可能会让你写这个偶！

 

手动释放和引用计数：
    熟悉windows开发的童鞋，对于引用计数应该是不会陌生的。任何“对象”（可以是类的实例，也可以是个资源）在内部会维护一个变量，称为计数器，对象初期化时，计数器初期化为1，任何对该对象的引用会使得计数器加一，同样的解引用会使得计数器减一，当计数器的值为0时，该对象销毁。引用计数使得一个资源（对象）可以在多处被使用，使用的场景类只需要关心自己什么时候需要该资源，什么时候不需要。
    在object-c中使用管理对象的生存期，可以使用下面的这些函数：
    retain -> 计数器加一
    realse -> 计数器减一
    注意的是当计数器=0，会自动调用对象的dealloc，就是析构函数了。

下面是一个Demo：

@interface Engine : NSObject
    @end

    @implementation Engine
    @end

@interface Car : NSObject
    {
        Engine* engine;
    }
    @end

    @implementation Car
    - (void) setterEngine: (Engine*) newEngine
    {
        [newEngine retain];
        [engine release];
        engine = newEngine;
    }

    - (void) dealloc
    {
        NSLog(@"car is dealloced");
        [super dealloc];
    }
    @end

    int main(char argc, char* argv[]) {

        Car* aCar = [[Car alloc] init];
        Engine* engine = [Engine new];
        [aCar setterEngine: engine];
        [engine release];

        [aCar release];

        return 0;
    }

对象的所有权
    因为object-c中的对象都是new出来的，没有像c++中的那种堆栈上的对象（不知道是不是这样，存疑。。），如果不使用autorelease或是GC的话，所有对象的生存期管理都必须由程序员自己来完成。这里记录下object-c基础编程里提到的编程惯用法, main（场景）中engine赋值给car之后，自己就没用了，立即release掉，注意的是setter函数的使用，要先retain newEngine，然后release掉旧的Engine，顺序不能错，如果反过来，当newEngine = oldEngine时，会导致engine先被解构掉。

再来看一个

int main(char argc, char* argv[])

{

    

NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; NSObject *o = [[NSObject alloc] init];    //retainCount为1 [o retain];    //retainCount为2 [o release]; //retainCount为1 [o autorelease]; //retainCount为1 [pool release]; //retaincount为0，触发dealloc方法

}

比如ClassA类的一个属性对象的Setter方法：

- ( void )setMyArray:(NSMutableArray *)newArray {     if (myArray != newArray) {         [myArray release];         myArray = [newArray retain];     } }

假设这个类的一个实例为'a'，调用setMyArray后，我们就可以说a拥有了一个新的myArray实例，也可以说a引用了一个新的myArray实例。其中调用的retain方法，使myArray的retainCount加一，我们需要注意以下两个地方：
1，setMyarray方法中，在retain之前先release了旧实例一次
2，在本实例的dealloc方法中，本应该是要再次release当前实例的，但回头看看参考内存管理准则。它并不合理，对吧。。。多了一次release。这里比较推荐的做法是：
[ myArray setMyArray:nil ];
这样可以巧妙的使当前实例release而不出错（我们可以向nil发送消息〜其实它本身就是个整数0），并符合我们的内存管理准则。更主要的是，很简单，你不需要考虑过多的事情。

另外一个比较容易忽略而又比较经典的问题是实例变量的循环引用，Objective-C为此区分了，其实也相当相当的简单：
1，强引用，上面讲的就是强引用，存在retainCount加一。
2，弱引用，但凡是assign声明并直接用指针赋值实现的被称之为弱引用，不存在retainCount加一的情况。

AutoreleasePool使Objective-C成为内存管理半自动化语言

如果仅仅是上面这些，很简单，对吧。但往往很多人都会迷糊在自动内存管理这块上，感觉像是有魔法，但其实原理也很简单〜

先看看最经典的程序入口程序：

NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; int retVal = UIApplicationMain(argc, argv, nil, nil); [pool release];

我们先把pool看成一个普通对象〜很简单，先是alloc，pool的retainCount为1。第三句release，retainCount为0，自动调用它的dealloc方法。它和任何其它普通对象没 任何区别。

魔法在哪里？
在声明pool后，release它之前的这段代码，所有段里的代码（先假设中间没有声明其它的AutoreleasePool实例），凡是调用了autorelase方法的实例，都会把它的retainCount加1，并在此pool实例中添1次此实例要回收的记录以做备案。当此pool实例dealloc时，首先会检查之前备案的所有实例，所有记录在案的实例都会依次调用它的release方法。

NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; NSObject *o = [[NSObject alloc] init]; [o autorelease];                                //在pool实例dealloc时，release一次此实例，重要的是并不是在此行去release NSLog(@ "o retainCount:%d" ,[o retainCount]);    //此时还可以看到我们的o实例还是可用的，并且retainCount为1 [pool release];    //pool 的 retainCount为0，自动调用其dealloc方法，我们之前备案的小o也将在这里release一次（因为咱们之前仅仅autorelease一次）

真对同一个实例，同一个Pool是可以多次注册备案(autorelease)的。在一些很少的情况化可能会出现这种需求：

NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; NSObject *o = [[NSObject alloc] init]; [o retain]; [o autorelease]; [o autorelease]; [pool release];

我们调用了两次A类(retainCount加1的方法)，使其retainCount为2，而接下来的两次autorelease方法调用，使其在pool中注册备案了两次。这里的pool将会在回收时调用此实例的两次release方法。使其retainCount降为0，完成回收内存的操作，其实这也是完全按照内存管理规则办事的好处〜

AutoreleasePool是被嵌套的！
池是被嵌套的，嵌套的结果是个栈，同一线程只有当前栈顶pool实例是可用的：

栈顶	pool_5
栈中	pool_4
栈中	pool_3
栈中	pool_2
栈底	pool_1

其代码如下：

NSAutoreleasePool *pool1 = [[NSAutoreleasePool alloc] init]; NSAutoreleasePool *pool2 = [[NSAutoreleasePool alloc] init]; NSAutoreleasePool *pool3 = [[NSAutoreleasePool alloc] init]; NSObject *o = [[NSObject alloc] init] autorelease]; [pool3 release]; [pool2 release]; [pool1 release];

我们可以看到其栈顶是pool3，o的autorelease是把当前的release放在栈顶的pool实例管理。。。也就是pool3。
在生命周期短，产生大量放在autoreleasePool中管理实例的情况下经常用此方法减少内存使用，达到内存及时回收的目的。

AutoreleasePool还被用在哪里？
在上面的例子里，也可以看到，我们在执行autorelease方法时，并没有时时的进行release操作〜它的release被延时到pool实例的dealloc方法里。这个小细节使我们的Objective-C用起来可以在方法栈中申请堆中的内存，创建实例，并把它放在当前pool中延迟到此方法的调用者释放〜