objective-c内存管理

引用计数是实例对象的内存回收惟一参考

引用计数(retainCount)是Objective-C管理对象引用的惟一依据。调用实例的release方法后，此属性减一，减到为零时对象的dealloc方法被自动调用，进行内存回收操做，也就是说咱们永不应手动调用对象的dealloc方法。

它的内存管理ＡＰＩ老简单老简单了，下面就是它主要操做接口：

1，alloc, allocWithZone,new(带初始化)
为对象分配内存，retainCount为“1”，并返回此实例

2，retain
retainCount 加“1”

3，copy,mutableCopy
复制一个实例，retainCount数为“1”，返回此实例。所获得的对象是与其它上下文无关的，独立的对象(干净对象)。

4，release
retainCount 减“1”，减到“0”时调用此对象的dealloc方法

5，autorelease
在当前上下文的AutoreleasePool栈顶的autoreleasePool实例添加此对象，因为它的引入使Objective-C（非GC管理环境）由全手动内存管理上升到半自动化。

Objective-C内存管理准则

咱们能够把上面的接口按对retainCount的操做性质归为两类，
Ａ类是加一操做：1，2，3
Ｂ类是减一操做：4，5（延时释放）

内存管理准则以下：
1，A与Ｂ类的调用次数保持一制
2，为了很好的保障准则一，以实例对象为单位，谁A了就谁Ｂ，没有第两者参与

例：

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中延迟到此方法的调用者释放〜