Objective-C内存管理入门

Objective-C内存管理入门

原文地址：http://blog.tianya.cn/blogger/post_read.asp?BlogID=1912959&PostID=28405275

1，你初始化(alloc/init)的对象，你需要释放(release)它。例如：

　　NSMutableArray aArray = [[NSArray alloc] init];

　　后，需要

　　[aArray release];

　　2，你retain或copy的，你需要释放它。例如：

　　[aArray retain]

　　后，需要

　　[aArray release];

　　3，被传递(assign)的对象，你需要斟酌的retain和release。例如：

　　obj2 = [[obj1 someMethod] autorelease];

　　对象2接收对象1的一个自动释放的值，或传递一个基本数据类型(NSInteger，NSString)时： 你或希望将对象2进行retain，以防止它在被使用之前就被自动释放掉。但是在retain后，一定要在适当的时候进行释放。

　　关于索引计数(Reference Counting)的问题

　　retain值 = 索引计数(Reference Counting)

　　NSArray对象会retain(retain值加一)任何数组中的对象。当NSArray被卸载(dealloc)的时候，所有数组中的对象会被执行一次释放(retain值减一)。不仅仅是NSArray，任何收集类(Collection Classes)都执行类似操作。例如NSDictionary，甚至UINavigationController。

　　Alloc/init建立的对象，索引计数为1。无需将其再次retain。

　　[NSArray array]和[NSDate date]等“方法”建立一个索引计数为1的对象，但是也是一个自动释放对象。所以是本地临时对象，那么无所谓了。如果是打算在全Class中使用的变量(iVar)，则必须retain它。

　　缺省的类方法返回值都被执行了“自动释放”方法。(*如上中的NSArray)

　　在类中的卸载方法“dealloc”中，release所有未被平衡的NS对象。(*所有未被autorelease，而retain值为1的)

　　Interface Builder参与的内存管理问题

　　要点：

　　如果一个变量在类中被定义为了 IBOutlet 那么你无需对其进行实例化，xib载入器会对其初始化。

　　如果一个变量在类中被定义为了 IBOutlet 那么你必须负责将其释放。xib载入器不会帮忙的… …

　　*切不要初始化两回，内存会溢出，而且对象锁定也会出错。

　　对autorelease的误解

　　A Cocoa的内存管理分为 索引计数法(Reference Counting/ Retain Count)和 垃圾收集法(Garbage Collection)。而iPhone上目前只支持前者，所以autorelease就成为很多人的“捷径”。

　　但是!autorelease其实并不是“自动释放”，不像垃圾收集法，对对象之间的关系侦测后发现垃圾-删除。但是autorelease其实是“延后释放”，在一个运行周期后被标记为autorelease会被释放掉。

　　切记小心使用autorelease，理解autorelease，防止在你还需要该对象的时候已经被系统释放掉了

　　Cocoa不同内存管理环境下的autorelease

　　H 混合内存管理环境：垃圾收集法(Garbage Collection)+索引计数法(Reference Counting)

　　虽然大多数情况下混合环境是不被推荐的，但是如果在这个情况下，autorelease需要注意以下事项：

　　垃圾收集混合环境下：应该使用drain方法，因为release在GC模式下没有意义

　　索引计数环境下：drain和release对于autoreleasepool(自动释放池)的效果相同

　　问题一：

　　value = [array objectAtIndex:n]; //得到一个数组中的对象

　　[arry removeObjectAtIndex:n]; //卸载那个对象

　　因为value得到了那个对象，但是由于另外一个拥有者release了该对象，所以其实value现在成了摇摆指针(无效数据)

　　问题二：

　　myArray = [NSArray array];

　　...

　　[myArray release];

　　NSArray返回的是一个自动释放对象，不仅myArray不应该在一段时间后release，而应该在适当的时候先retain，以防止该array被系统误释放。

　　问题三：

　　rocket = [rocketLauncher aRocket];

　　[rocketLauncher release];

　　和array这种数据收集类对象一样，如果我们得到了一个类的子对象而不retain它，那么在原父类被释放的时候，这个rocket其实也会失去其意义。

　　原来简单解释过属性定义(Property) ，并且提起了简单的retain，copy，assign的区别。那究竟是有什么区别呢?

　　assign就不用说了，因为基本上是为简单数据类型准备的，而不是NS对象们。

　　Retain vs. Copy!!

　　copy： 建立一个索引计数为1的对象，然后释放旧对象

　　retain：释放旧的对象，将旧对象的值赋予输入对象，再提高输入对象的索引计数为1

　　那上面的是什么该死的意思呢?

　　Copy其实是建立了一个相同的对象，而retain不是：

　　比如一个NSString对象，地址为0×1111，内容为@”STR”

　　Copy到另外一个NSString之后，地址为0×2222，内容相同，新的对象retain为1，旧有对象没有变化

　　retain到另外一个NSString之后，地址相同(建立一个指针，指针拷贝)，内容当然相同，这个对象的retain值+1

　　也就是说，retain是指针拷贝，copy是内容拷贝。哇，比想象的简单多了…

　　iPhone系统中的Objective-C的内存管理机制是比较灵活的，即可以拿来像C/C++一样用，也可以加个AutoreleasePool让它升级为半自动化的内存管理语言。当然，也不能拿JAVA虚拟机中的全自动化GC来比～

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

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

　　它的内存管理API老简单老简单了，下面就是它主要操作接口：

　　1，alloc, allocWithZone,new(带初始化)

　　为对象分配内存，retainCount为“1”，并返回此实例

　　2，release

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

　　3，retain

　　retainCount 加“1”

　　4，copy,mutableCopy

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

　　5，autorelease

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

　　九、Objective-C内存管理准则

　　我们可以把上面的接口按对retainCount的操作性质归为两类，

　　A类是加一操作：1，3，4

　　B类是减一操作：2，5(延时释放)

　　内存管理准则如下：

　　1，A与B类的调用次数保持一制

　　2，为了很好的保障准则一，以实例对象为单位，谁A了就谁B，没有第二者参与

　　代码：

　　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加一的情况。

　　为什么不能直接调用dealloc而是release

　　dealloc不等于C中的free，dealloc并不将内存释放，也不会将索引计数(Reference counting)降低。于是直接调用dealloc反而无法释放内存。

　　在Objective-C中，索引计数是起决定性作用的。

　　十二、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_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中延迟到此方法的调用者释放～

　　以上就是我想到的内存管理总结～～～～也就这么多吧～日常工作用够用了～不够的，没想到的大家补充～