ObjC，Objective-C的内存管理之-引用计数

2024-04-06 04:59•Android•阅读 2127

obj-c本质就是"改进过的c语言"，大家都知道c语言是没有垃圾回收(GC)机制的(注：虽然obj-c2.0后来增加了GC功能，但是在 iphone上不能用，因此对于iOS平台的程序员来讲，这个几乎没啥用)，所以在obj-c中写程序时，对于资源的释放得由开发人员手动处理，相对要费心一些。

引用计数

这是一种古老但有效的内存管理方式。每个对象(特指：类的实例)内部都有一个retainCount的引用计数，对象刚被创建时，retainCount为1，可以手动调用retain方法使retainCount+1，同样也可以手动调用release方法使retainCount-1，调用release方法时，如果retainCount值减到0，系统将自动调用对象的dealloc方法(类似于c#中的dispose方法)，开发人员可以在dealloc中释放或清理资源。

1、基本用法

为了演示这种基本方式，先定义一个类Sample

类接口部分Sample.h

1 //

2 // Sample.h

3 // MemoryManage_1

4 //

5 // Created by jimmy.yang on 11-2-19.

7 //

9 #import <Foundation/Foundation.h>

11 @interface Sample : NSObject {

13 }

14 @end

类实现部分Sample.m

1//

2// Sample.m

3// MemoryManage_1

4//

5// Created by jimmy.yang on 11-2-19.

7//

9#import "Sample.h"

11@implementation Sample

13-(id) init

14{

15 if (self=[super init]){

16 NSLog(@"构造函数被调用了！当前引用计数:%d",[self retainCount]);

17 }

18 return (self);

19}

21-(void) dealloc{

22 NSLog(@"析构函数将要执行...，当前引用计数:%d",[self retainCount]);

23 [super dealloc];

24}

25@end

代码很简单，除了"构造函数"跟"析构函数"之外，没有任何其它多余处理。

主程序调用

1#import <Foundation/Foundation.h>

2#import "Sample.h"

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

6 Sample *_sample = [Sample new]; //构造函数被调用了！当前引用计数:1

7 NSLog(@"_sample.retainCount=%d",[_sample retainCount]);//1

9 [_sample retain];

10 NSLog(@"_sample.retainCount=%d",[_sample retainCount]);//2

12 [_sample retain];

13 NSLog(@"_sample.retainCount=%d",[_sample retainCount]);//3

15 [_sample release];

16 NSLog(@"_sample.retainCount=%d",[_sample retainCount]);//2

18 [_sample release];

19 NSLog(@"_sample.retainCount=%d",[_sample retainCount]);//1

21 [_sample release];//析构函数将要执行...，当前引用计数:1

22 NSLog(@"_sample.retainCount=%d",[_sample retainCount]);//1，注：即便是在析构函数执行后，如果立即再次引用对象的retainCount，仍然返回1,但以后不管再试图引用该对象的任何属性或方法，都将报错

23 NSLog(@"_sample.retainCount=%d",[_sample retainCount]);//对象被释放之后，如果再尝试引用该对象的任何其它方法，则报错

24 //[_sample retain];//同上，会报错

26 return 0;

27}

这段代码主要验证:对象刚创建时retainCount是否为1，以及retain和release是否可以改变retainCount的值，同时retainCount减到0时，是否会自动执行dealloc函数

nil 的问题:

1.1 如果仅声明一个Sample类型的变量(其实就是一个指针)，而不实例化，其初始值为nil

1.2 变量实例化以后，就算release掉，dealloc被成功调用，其retainCount并不马上回到0(还能立即调用一次且仅一次[xxx retainCount])，而且指针变量本身也不会自动归为nil值

1.3 dealloc被调用后，必须手动赋值nil，retainCount才会自动归0

以上结论是实际试验得出来的，见下面的代码：

1Sample *s ;

2NSLog(@"s %@,retainCount=%d",s==nil?@"is nil":@"is not nil",[s retainCount]);//s is nil,retainCount=0

3s = [Sample new];

4NSLog(@"s %@,retainCount=%d",s==nil?@"is nil":@"is not nil",[s retainCount]);//s is not nil,retainCount=1

5[s release];

6NSLog(@"s %@,retainCount=%d",s==nil?@"is nil":@"is not nil",[s retainCount]);//s is not nil,retainCount=1

7//NSLog(@"s %@,retainCount=%d",s==nil?@"is nil":@"is not nil",[s retainCount]);//报错：Program received signal: “EXC_BAD_ACCESS”.

8s = nil;

9NSLog(@"s %@,retainCount=%d",s==nil?@"is nil":@"is not nil",[s retainCount]);//s is nil,retainCount=0

所以千万别用if (x == nil) 或 if ([x retainCount]==0)来判断对象是否被销毁，除非你每次销毁对象后，手动显式将其赋值为nil

2、复杂情况

上面的示例过于简章，只有一个类自己独耍，如果有多个类，且相互之间有联系时，情况要复杂一些。下面我们设计二个类Shoe和Man（即“鞋子类”和”人“），每个人都要穿鞋，所以Man与Shoe之间应该是Man拥有Shoe的关系。

Shoe.h接口定义部分

1 #import <Foundation/Foundation.h>

4 @interface Shoe : NSObject {

5 NSString* _shoeColor;

6 int _shoeSize;

7 }

9 //鞋子尺寸

10 -(void) setSize:(int) size;

11 -(int) Size;

13 //鞋子颜色

14 -(void) setColor:(NSString*) color;

15 -(NSString*) Color;

17 //设置鞋子的颜色和尺码

18 -(void) setColorAndSize:(NSString*) pColor shoeSize:(int) pSize;

20 @end

Shoe.m实现部分

1 //

2 // Shoe.m

3 // MemoryManage_1

4 //

5 // Created by jimmy.yang on 11-2-19.

7 //

9 #import "Shoe.h"

12 @implementation Shoe

14 //构造函数

15 -(id)init

16 {

17 if (self=[super init]){

18 _shoeColor = @"black";

19 _shoeSize = 35;

20 }

21 NSLog(@"一双 %@ %d码的鞋子造好了！",_shoeColor,_shoeSize);

22 return (self);

23 }

25 -(void) setColor:(NSString *) newColor

26 {

27 _shoeColor = newColor;

28 }

30 -(NSString*) Color

31 {

32 return _shoeColor;

33 }

35 -(void) setSize:(int) newSize

36 {

37 _shoeSize = newSize;

38 }

40 -(int) Size

41 {

42 return _shoeSize;

43 }

45 -(void) setColorAndSize:(NSString *)color shoeSize:(int)size

46 {

47 [self setColor:color];

48 [self setSize:size];

49 }

52 //析构函数

53 -(void) dealloc

54 {

55 NSLog(@"%@ %d码的鞋子正在被人道毁灭！",_shoeColor,_shoeSize);

56 [super dealloc];

57 }

60 @end

Man.h定义部分

1 //

2 // Man.h

3 // MemoryManage_1

4 //

5 // Created by jimmy.yang on 11-2-20.

7 //

9 #import <Foundation/Foundation.h>

10 #import "Shoe.h"

13 @interface Man : NSObject {

14 NSString *_name;

15 Shoe *_shoe;

16 }

19 -(void) setName:(NSString*) name;

20 -(NSString*)Name;

22 -(void) wearShoe:(Shoe*) shoe;

23 @end

Man.m实现部分

1 //

2 // Man.m

3 // MemoryManage_1

4 //

5 // Created by jimmy.yang on 11-2-20.

7 //

9 #import "Man.h"

12 @implementation Man

14 //构造函数

15 -(id)init

16 {

17 if (self=[super init]){

18 _name = @"no name";

19 }

20 NSLog(@"新人\"%@\"出生了！",_name);

21 return (self);

22 }

25 -(void) setName:(NSString *)newName

26 {

27 _name =newName;

28 }

30 -(NSString*)Name

31 {

32 return _name;

33 }

35 -(void) wearShoe:(Shoe *)shoe

36 {

37 _shoe = shoe;

38 }

40 //析构函数

41 -(void) dealloc

42 {

43 NSLog(@"\"%@\"要死了！ ",_name);

44 [super dealloc];

45 }

47 @end

main函数调用

1#import <Foundation/Foundation.h>

2#import "Shoe.h"

3#import "Man.h"

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

7 Man *jimmy = [Man new];

8 [jimmy setName:@"Jimmy"];

11 Shoe *black40 =[Shoe new];

12 [black40 setColorAndSize:@"Black" shoeSize:40];

14 [jimmy wearShoe:black40];

16 [jimmy release];

17 [black40 release];

19 return 0;

21}

2011-02-23 13:05:50.550 MemoryManage[253:a0f] 新人"no name"出生了！

2011-02-23 13:05:50.560 MemoryManage[253:a0f] 一双 black 35码的鞋子造好了！

2011-02-23 13:05:50.634 MemoryManage[253:a0f] "Jimmy"要死了！

2011-02-23 13:05:50.636 MemoryManage[253:a0f] Black 40码的鞋子正在被人道毁灭！

以上是输出结果，一切正常，jimmy与black40占用的资源最终都得到了释放。但是有一点不太合理，既然鞋子(black40)是属于人 (jimmy)的，为什么人死了（即:[jimmy release]），却还要main函数来责任烧掉他的鞋子？(即：main函数中还是单独写一行[black40 release]) 貌似人死的时候，就连带自上的所有东西一并带走，这样更方便吧。

ok，我们来改造一下Man.m中的dealloc()方法，改成下面这样：

1//析构函数

2-(void) dealloc

4 NSLog(@"\"%@\"要死了！ ",_name);

5 [_shoe release];//这里释放_shoe

6 [super dealloc];

即：在Man被销毁的时候，先把_shoe给销毁。这样在main()函数中，就不再需要单独写一行[black40 release]来释放black40了.

现在又有新情况了：jimmy交了一个好朋友mike，二人成了铁哥们，然后jimmy决定把自己的鞋子black40，跟mike共同拥有，于是main函数就成了下面这样：

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

3 Man *jimmy = [Man new];

4 [jimmy setName:@"Jimmy"];

6 Shoe *black40 =[Shoe new];

7 [black40 setColorAndSize:@"Black" shoeSize:40];

9 [jimmy wearShoe:black40];

11 Man *mike = [Man new];

12 [mike setName:@"mike"];

13 [mike wearShoe:black40];//mike跟jimmy，现在共同拥有一双40码黑色的鞋子

15 [jimmy release];

16 [mike release];

18 return 0;

19}

麻烦来了：jimmy在挂掉的时候(即[jimmy release]这一行)，已经顺手把自己的鞋子也给销毁了(也许他忘记了mike也在穿它)，然后mike在死的时候，准备烧掉自已的鞋子black40，却被告之该对象已经不存在了。于是程序运行报错：

Running…

2011-02-23 13:38:53.169 MemoryManage[374:a0f] 新人"no name"出生了！

2011-02-23 13:38:53.176 MemoryManage[374:a0f] 一双 black 35码的鞋子造好了！

2011-02-23 13:38:53.177 MemoryManage[374:a0f] 新人"no name"出生了！

2011-02-23 13:38:53.179 MemoryManage[374:a0f] "Jimmy"要死了！

2011-02-23 13:38:53.181 MemoryManage[374:a0f] Black 40码的鞋子正在被人道毁灭！

2011-02-23 13:38:53.183 MemoryManage[374:a0f] "mike"要死了！

Program received signal: “EXC_BAD_ACCESS”.

sharedlibrary apply-load-rules all

(gdb)

上面红色的部分表示程序出错了：Bad_Access也就是说访问不存在的地址。

最解决的办法莫过于又回到原点，Man.m的dealloc中不连带释放Shoe实例，然后把共用的鞋子放到main函数中，等所有人都挂掉后，最后再销毁Shoe实例，但是估计main()函数会有意见了：你们二个都死了，还要来麻烦我料理后事。

举这个例子无非就是得出这样一个原则：对于new出来的对象，使用retain造成的影响一定要运用相应的release抵消掉，反之亦然，否则，要么对象不会被销毁，要么过早销毁导致后面的非法引用而出错。

下一回，我们来看看如何用自动释放池来换一个方式来处理引用计数。

作者：菩提树下的杨过

出处：http://yjmyzz.cnblogs.com

本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。

上一篇 »Python如何释放内存？
下一篇 »python是如何进行内存管理的？

ObjC，Objective-C的内存管理之-引用计数

相关推荐

深入理解java虚拟机之——JVM垃圾回收策略总结

Effective Objective-C 2.0 — 第10条：在既有类中使用关联对象存放自定义数据

Objective-C中的内存回收机制简介

Objective-C 基础教程第九章,内存管理

Objective-C中 copy, tetain, assign , readonly , readwrite, nonatomic区别

【转】iPhone/Mac Objective-C内存管理教程和原理剖析，二口诀与范式

iPhone/Mac Objective-C内存管理教程和原理剖析

Objective-c开发教程--MRC和ARC混编