Objective-C高级编程-自动引用计数ARC

什么是自动引用计数

自动引用计数(ARC, Automatic Reference Counting),即编译器自动在合适的地方插入retain/release代码, 不需要我们手动维护对象的引用。

内存管理的思考方式

Objective-C中内存管理方式的设计有以下规则:

  • 自己生成的对象,自己持有;
  • 非自己生成的对象,自己也能持有;
  • 不再需要自己持有对象时释放;
  • 非自己持有的对象无法释放。
对象操作 Objective-C方法
生成并持有对象 alloc/new/copy/mutableCopy等方法
持有对象 retain方法
释放对象 release方法
废弃对象 dealloc方法

非自己生成的对象, 自己也能持有:

1
2
id obj = [NSMutableArray array]; // 取得对象存在, 但自己并不持有对象
[obj retain]; // 自己持有对象

不再需要自己持有对象时释放:

1
2
id obj = [[NSObject alloc] init]; // 自己持有对象
[obj autorelease]; // 取得的对象存在, 但自己不持有对象

无法释放非自己持有的对象:

1
2
id obj = [NSMutableArray array]; // 取得对象存在, 但自己并不持有对象
[obj release]; // 释放了非自己持有的对象!会导致应用程序崩溃

永远不要去释放非自己持有的对象!

在Objective-C的对象中使用整数进行引用计数:

  • 调用alloc/retain方法后,引用计数+1
  • 调用release后,引用计数-1
  • 引用计数为0时,调用dealloc废弃对象

GNUstep将引用计数保存在对象占用内存块头部的结构体(struct obj_layout)变量(retained)中,而苹果的实现则是采用散列表(引用计数表)来管理引用计数。

GNUstep实现的好处:少量代码即可完成;能够统一管理引用计数用内存块与对象用内存块。

苹果实现的好处:对象用内存块的分配无需考虑内存块头部;引用计数表各记录中存有内存块地址,可从各个记录追溯到各对象的内存块。

autorelease

autorelease与C语言中的自动变量(局部变量)的特性相似,当超出其作用域时,对象实例的release方法被调用。但与C语言不同的是,autorelease允许编程人员手动设定变量的作用域。

而在Cocoa框架中,每一个NSRunLoop对应一个线程,每个线程维护一个autoreleasepool。其具体过程如下:

1
RunLoop开始 -> 创建autoreleasepool -> 线程处理事件循环 -> 废弃autoreleasepool -> RunLoop结束 -> 等待下一个Loop开始

注意不能对NSAutoreleasePool类对象调用autorelease方法,因为在NSAutoreleasePool类中autorelease方法已被重载,因此这样调用会发成异常。

所有权修饰符介绍

在ARC中,id及其他对象默认就是__strong修饰符。在MRC中,使用__strong修饰符,不必再次键入retain/release。持有强引用的变量超出其作用域时被废弃,随着强引用的失效,引用的对象会随之释放。

__weak

__weak修饰符解决循环引用问题。当弱引用的对象被废弃时,则此弱引用将自动失效并置为nil

通过__weak变量访问对象实际上必定是访问注册到autoreleasepool的对象,因为该修饰符只持有对象的弱引用,在访问对象的过程中该对象可能被废弃。如果把要访问的对象注册到autoreleasepool中,那么在block结束之前都能确保该对象存在.

__unsafe_unretained

不安全的修饰符,附有该修饰符的变量不属于编译器的内存管理对象。该修饰符与__weak一样是弱引用,并不能持有对象。并且访问该修饰符的变量时如果不能确保其确实存在,则应用程序会崩溃。

__autoreleasing

对象赋值给__autoreleasing修饰的变量相当于MRC下手动调用autorelease方法。可理解为ARC下用@autoreleasepool block代替NSAutoreleasePool类,用__autoreleasing修饰符的变量代替autorelease方法。

但是,显式使用autoreleasing修饰符跟strong一样罕见。

id类型的指针或者对象的指针会被隐式附上__autoreleasing修饰符:

1
2
3
4
> id obj == id __strong obj;
> id *obj == id __autoreleasing *obj;
> NSObject **obj == NSObject * __autoreleasing *obj;
>

在某些方法调用时,应当注意变量的修饰符的一致性:

1
2
3
4
5
6
- (BOOL)performOperationWithError:(NSError **)error {
/* 错误的赋值 */
*error = [[NSError alloc] initWithDomain:myDomain
code: errorCode userInfo:nil];
return NO;
}

可以看到,这个方法中的参数(NSError **)error等价于NSError * __autoreleasing *)error,将一个__strong类型的变量引用赋值给一个__autoreleasing类型的变量是错误的。

同样的,以下代码也会产生编译错误:

1
2
NSError *error = nil;
NSError **pError = &error; /* 错误 */

赋值给对象指针时,所有权修饰符必须一致:

1
2
NSError *error = nil;
NSError * __strong *pError = &error; /* 正确 */

编译器特性

编译器会检查方法名是否以alloc/new/copy/mutableCopy开始,如果不是则自动将返回值对象注册到autoreleasepoolinit方法返回值对象不注册到autoreleasepool)。

ARC规则

  • 不能使用retain/release/retainCount/autorelease
  • 不能使用NSAllocateObject/NSDeallocateObject
  • 须遵循内存管理的方法命名规则
  • 不要显式调用dealloc(不能手动调用的dealloc方法,但可以重载)
  • 使用@autoreleasepool block代替NSAutoreleasePool
  • 不能使用区域(NSZone)
  • 对象型变量不能作为C语言结构体(struct/union)的成员
  • 显式转换idvoid *

不能使用NSAllocateObject/NSDeallocateObject

alloc方法的实现实际上是通过直接调用NSAllocateObject函数来生成并持有对象,ARC下禁止使用NSAllocateObject函数与NSDeallocateObject函数。

须遵循内存管理的方法命名规则

只有作为alloc/new/copy/mutableCopy方法的返回值取得对象,才能自己生成并持有对象,其余情况均为取得非自己生成并持有的对象。以下为ARC下编译器隐式所做的实现:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
+ (Person *)newPerson {
Person *person = [[Person alloc] init];
return person;
/* 该方法以new开始,所以直接返回对象本身,无需调用autorelease */
}
+ (Person *)onePerson {
Person *person = [[Person alloc] init];
return person;
/* 该方法不以alloc/new/copy/mutableCopy开始,所以返回的是[person autorelease] */
}
- (void)doSomething {
Person *personOne = [Person newPerson];
// ...
Person *personTwo = [Person onePerson];
// ...
/* 当方法结束时,ARC会自动插入[personOne release] */
}

ARC下还有一条命名规则:以init名称开始的方法必须是实例方法(对象方法),并且必须返回id类型或类所属类型的对象。返回的对象不注册到autoreleasepool上。实际上只是对alloc方法返回值的对象做初始化处理并返回该对象。

不能使用区域(NSZone)

在现在的运行时系统(Objective-C 2.0后)中,NSZone已被忽视。基于zone管理内存空间的方式已被更高效的系统管理所取代。

显式转换idvoid *

__bridge转换

单纯的类型转换(不安全,有可能造成悬垂指针):

1
2
3
id obj = [[NSObject alloc] init];
void *p = (__bridge void *)obj;
id o = (__bridge id)p;

__bridge_retained转换

可使要转换赋值的变量也持有所赋值的对象:

1
2
3
id obj = [[NSObject alloc] init];
void *p = (__bridge_retained void *)obj;
// 相当于加上 [(id)p retain];

则obj与p同时持有该对象的引用。

__bridge_transfer转换

__bridge_retained相反,被转换的变量所持有的对象在该变量被赋值给转换目标变量后随之释放:

1
2
3
id obj = [[NSObject alloc] init];
void *p = (__bridge_transfer void *)obj;
// 相当于加上 [(id)p retain]; [obj release];

Objective-C对象与Core Foundation对象转换

__ bridge_retained转换与retain类似,__ bridge_transfer转换与release类似。这两种转换多用于Foundation对象与Core Foundation对象之间的转换:

1
2
3
4
5
6
7
CFTypeRef CFBridgingRetain(id X) {
return (__bridge_retained CFTypeRef)X;
}
id CFBridgingRelease(CFTypeRef X) {
return (bridge_transfer id)X;
}

属性

1
@property (nonatomic, strong) NSString *name;

在ARC下,以下可作为这种属性声明中使用的属性来用:

属性声明的属性 所有权修饰符
assign __unsafe_unretained修饰符
copy __strong修饰符(但是赋值的是被复制的对象)
retain __strong修饰符
strong __strong修饰符
unsafe_unretained __unsafe_unretained修饰符
weak __weak修饰符

以上各种属性赋值给指定的属性中就相当于赋值给附加各属性对应的所有权修饰符的变量中.

数组

下面我们就来看看数组中使用附有__strong修饰符变量的例子:

1
2
3
4
5
{
id objs[2];
objs[0] = [[NSObject alloc] init];
objs[1] = [NSMutableArray array];
}

数组超出其变量作用域时,数组中各个附有的__strong修饰符的变量也随之失效,其强引用消失,所赋值的对象也随之释放。这与不使用数组的情形完全一样。

将附有__strong修饰符的变量作为动态数组来使用时又如何呢?在这种情况下,根据不同的目的选择使用NSMutableArray、NSMutableDictionary、NSMutableSet 等Foundation框架的容器。这些容器会恰当地持有追加的对象并为我们管理这些对象。

像这样使用容器虽然更为合适,但在C 语言的动态数组中也可以使用附有 strong 修饰符的变量,只是必须要遵守一些事项。

声明动态数组用指针

1
id __strong *array = nil;

如前所述,由于id *类型默认为id __autoreleasing类型,所以有必要显式指定为__strong修饰符。另外,虽然保证了附有__strong修饰符的id型变量被初始化为nil,但并不保证附有__strong修饰符的id指针型变量被初始化为nil。

另外,使用类名时如下记述:

1
NSObject * __strong *array = nil;

其次,使用calloc函数确保想分配的附有__strong修饰符变量的容量占有的内存块:

1
array = (id __strong *)calloc(entries, sizeof(id));

该源代码分配了entries 个所需的内存块。由于使用附有__strong修饰符的变量前必须先将其初始化为nil,所以这里使用使分配区域初始化为0的calloc函数来分配内存。如果不使用calloc函数,使用malloc函数分配内存后再使用memset等函数将内存填充为0也可以达到同样的效果。

但是,像下面代码这样将nil代入到malloc函数所分配的数组各元素中来初始化是非常危险的:

1
2
3
4
/* 错误:nil赋值给不可靠的内存地址 */
array = (id __strong *)malloc(sizeof(id) * entries);
for (NSUInteger i = 0; i < entries; ++i)
array[i] = nil;

这是因为由malloc函数分配的内存区域没有被初始化为0,因此nil会被赋值给附有__strong修饰符的并被赋值了随机地址的变量中,从而在块之外释放一个不存在的对象。在分配内存时推荐使用calloc函数。

像这样,通过calloc函数分配的动态数组就能完全像静态数组一样使用:

1
array[0] = [[NSObject alloc] init];

但是,在动态数组中操作附有__strong修饰符的变量与静态数组有很大差异,需要自己释放所有的元素。

如以下源代码所示,在只是简单地用free函数废弃了数组用内存块的情况下,数组各元素所赋值的对象不能再次释放,从而引起内存泄漏:

1
2
/* 错误:数组元素不能再次释放,内存泄露 */
free(array);

这是因为在静态数组中,编译器能够根据变量的作用域自动插入释放赋值对象的代码,而在动态数组中,编译器不能确定数组的生存周期,所以无从处理。如以下源代码所示,一定要将nil赋值给所有元素中,使得元素所赋值对象的强引用失效,从而释放那些对象。在此之后,使用free 函数废弃内存块。

1
2
3
for (NSUInteger i = 0; i < entries; ++i)
array[i] = nil;
free(array);

同初始化时的注意事项相反,即使用memset等函数将内存填充为0也不会释放所赋值的对象。这非常危险,只会引起内存泄漏。对于编译器,必须明确地使用赋值给附有__strong修饰符变量的源代码。所以请注意,必须将nil赋值给所有数组元素。

另外,使用memcpy函数拷贝数组元素以及realloc函数重新分配内存块也会有危险。由于数组元素所赋值的对象有可能被保留在内存中或是重复被废弃,所以这两个函数也禁止使用。

再者,我们也可以像使用__strong修饰符那样使用附有__weak修饰符变量的动态数组。在__autoreleasing修饰符的情况下,因为与设想的使用方法有差异,所以最好不要使用动态数组。

由于__unsafe_unretained修饰符在编译器的内存管理对象之外,所以它与void *类型一样,只能作为C语言的指针类型来使用。