第三讲：Obj-C 内存管理1

转：http://tigercat1977.blog.163.com/blog/static/2141561122012111293337435/

第三讲：Obj-C 内存管理1 - 黄金法则

主要内容
      OC内存管理原理
      OC内存管理相对 C/C++ 有何好处
      OC内存管理的 alloc, retain, release
      遛狗原则
      OC 对象生命周期

内存管理黄金法则
      The basic rule to apply is Everything that increases the refernce counter with alloc,
[mutable] copy [Whith Zone:] or retain is charge of the corresponding [auto] release.
      如果对一个对象使用了 alloc, [mutable] copy, retain,
那么你必须使用相应的 release 或者 autorelease

内存管理类型定义
     基本类型   任何 C 的类型，如：
     int， short, char, long, long long, struct, enum, union 等属于基本类型或者结构体
     内存管理对于 C 语言基本类型无效

     OC类型 (非基本类型)
     任何继承于 NSObject 类的对象都属于 OC 类型
     也就是除了 C 之外的其他类型

OC 对象结构

内存管理1 - 黄金法则 - tigercat1977 - tiger notes" src="http://img9.ph.126.net/U5zoH737mB8ivqLU7oj40w==/6597235792913799179.jpg" width="479" height="254" />

C / C++ 内存管理原理

内存管理1 - 黄金法则 - tigercat1977 - tiger notes" src="http://img8.ph.126.net/I6g427t-7FZM4IE0ep-aWg==/6597992256912416598.jpg" width="476" height="225" />

C / C++ 内存管理代码
      Int *p1 = malloc(100);
      Int *p2 = p1;
      Int *p3 = p1;
      Free(p2);

      Free(p2);

内存管理对象
      对于OC的对象，非基本对象（int, short, struct）
      NSObject, 凡是继承于 NSObject
      每一个对象都有一个 retainCount 计数器。表示当前的被应用的计数器。如果计数为0，那么就真正的释放这个对象

内存管理图示
      这就是引用计数的理论。在实际应用中，通过只有两个原因我们才会创建一个对象：
          1. 作为一个实例变量保留。
          2. 在函数内部作为临时变量使用。
      大多数情况下，一个实例变量的设置器（setter）会自动释放（autorelease）
      原来引用的对象，同时保留（retain）新的。你只需要保证在 dealloc 函数中释放（release）了它就行了。

内存管理1 - 黄金法则 - tigercat1977 - tiger notes" src="http://img0.ph.126.net/7wgDw3qbHMTEabom3-bdBw==/6597958172051956680.jpg" width="563" height="155" />

遛狗原理

内存管理1 - 黄金法则 - tigercat1977 - tiger notes" src="http://img8.ph.126.net/rzKrA9nGturFSBehvQ8VqA==/6597233593890536288.jpg" width="548" height="281" />

OC内存管理

内存管理1 - 黄金法则 - tigercat1977 - tiger notes" src="http://img7.ph.126.net/ZbgzV9jFvJjD81aOFPTIpw==/6598267134819188007.jpg" width="546" height="276" />

alloc retain release 函数
      alloc 函数是创建对象使用，创建完成后计数器为 1
      只用一次

      retain 是对一个对象的计数器 +1
      可以调用多次

      release 是对一个对象计数器 -1
      减到 0 对象就会从内存中释放

OC内存管理
      Objective - C 类中实现了引用计数器，对象知道当前被引用了次数。
      最初对象的计数器是 1 。
      如果需要引用对象了，可以给对象发送 release 消息，这样对象计数器就加 1。
      当不需要引用对象了，可以给对象发送 release 消息，这样对象计数器就减 1。
      当计数器减到 0，自动调用对象的 dealloc 函数，对象就会释放内存。
      计数器为 0 的对象不能再使用 release 和其他方法。

retain / release 例子
      NSMutableString *str = [[NSMutableString alloc] init];
                                      // str 计数器为 1
      [str retain];                // str 计数器为 2
      [str retain];                // str 计数器为 3
      [str release];              // str 计数器为 2
      [str release];              // str 计数器为 1
      [str release];              // str 计数器为 0，   对象释放内存

内存管理总结
Objective - C 的内存管理机制与 .Net / Jave 那种全自动的垃圾回收机制是不同的，它本质上还是 C 语言中的手动管理方式，只不过稍微加了一些自动方式。
      Objective - C 的内存管理是基于引用计数的。要做的事情只是关注的引用，而释放内存的工作实际上由运行环境完成。
      在最简单的情形中，分配的（alloc）对象，或者是保留（retain）在一些地方的对象，都需要发送一个 release 消息。这也意味着，如果使用了一次 alloc，然后又 retain 了一次，那你需要 release 两次才能释放对象的内存。

下面三种增加对象技术器
      1. 当明确的使用 alloc 方法来分配对象。
      2. 当明确的使用 copy [WithZone:] 或者 murableCopy[WithZone:] 来 copy 对象时。
      3. 当明确使用 retain 消息。

      上述三种方法使得计数器增加，那么就需要使用 [auto] release 来明确释放对象，也就是递减计数器。

遛狗原则举例（一只狗时）这方法不够完善

// Dog.h #import <Foundation/Foundation.h> @interface Dog : NSObject { int _ID; } @property int ID; @end

// Dog.m #import "Dog.h" @implementation Dog @synthesize ID = _ID; - (void) dealloc { NSLog(@"dog %d is dealloc", _ID); [super dealloc]; } @end

// Person.h #import <Foundation/Foundation.h> #import "Dog.h" @interface Person : NSObject { Dog *_dog; } - (void) setDog:(Dog *)aDog; - (Dog *) dog; @end

// Persen.m

@implementation Person - (void) setDog:(Dog *)aDog { if (aDog != _dog) { // _dog = aDog; // [_dog retain]; _dog = [aDog retain]; // 让计数器＋1 } } - (Dog *) dog { return _dog; } - (void) dealloc { NSLog(@"person is delloc"); // 把人拥有的 _dog 释放 [_dog release]; [super dealloc]; } @end

// main.m #import <Foundation/Foundation.h> #import "Dog.h" #import "Person.h" int main (int argc, const char * argv[]) { @autoreleasepool { NSLog(@"Hello, World!"); Dog *dog1 = [[Dog alloc] init]; [dog1 setID:1]; Person *xiaoLi = [[Person alloc] init]; // 小丽要遛狗 [xiaoLi setDog:dog1]; Person *xiaoWang = [[Person alloc] init]; [xiaoWang setDog:dog1]; NSLog(@"dog1 retain count1 is %ld", [dog1 retainCount]); // 输出：dog1 retain count1 is 3 [dog1 release]; NSLog(@"dog1 retain count2 is %ld", [dog1 retainCount]); // 输出：dog1 retain count2 is 2 [xiaoWang release]; NSLog(@"dog1 retain count3 is %ld", [dog1 retainCount]); // 输出：person is delloc // ：dog1 retain3 count is 1 [xiaoLi release]; // 输出：person is delloc // ：dog 1 is dealloc } return 0; }

遛狗原则举例2 （两只狗时）这方法比较完善

// Dog.h #import <Foundation/Foundation.h> @interface Dog : NSObject { int _ID; } @property int ID; @end

// Dog.m #import "Dog.h" @implementation Dog @synthesize ID = _ID; - (void) dealloc { NSLog(@"dog %d is dealloc", _ID); [super dealloc]; } @end

// Person.h #import <Foundation/Foundation.h> #import "Dog.h" @interface Person : NSObject { Dog *_dog; } - (void) setDog:(Dog *)aDog; - (Dog *) dog; @end

// Persen.m

@implementation Person - (void) setDog:(Dog *)aDog { if (aDog != _dog) {

[_dog release]; // 要注意的地方，提前 release _dog = [aDog retain]; // 让计数器＋1 } } - (Dog *) dog { return _dog; } - (void) dealloc { NSLog(@"person is delloc"); // 把人拥有的 _dog 释放 [_dog release]; [super dealloc]; } @end

// main.m #import <Foundation/Foundation.h> #import "Dog.h" #import "Person.h" int main (int argc, const char * argv[]) { @autoreleasepool { Dog *dog1 = [[Dog alloc] init]; [dog1 setID:1]; Dog *dog2 = [[Dog alloc] init]; [dog2 setID:2]; Person *xiaoLi = [[Person alloc] init]; // 小丽要遛狗 [xiaoLi setDog:dog1]; [xiaoLi setDog:dog2]; NSLog(@"dog1 retain count is %ld", [dog1 retainCount]); //输出：dog1 retain count is 1 [dog1 release]; //输出：dog 1 is dealloc NSLog(@"dog2 retain count is %ld", [dog2 retainCount]); //输出：dog2 retain count is 2 [xiaoLi release]; //输出：person is delloc NSLog(@"dog2 retain count is %ld", [dog2 retainCount]); //输出：dog2 retain count is 1 [dog2 release]; //输出：dog 2 is dealloc } return 0; }