写在前面

这篇文章是阅读 Transitioning to ARC Release Notes 的笔记。

主要内容是关于 ARC 的规则。

简介

Automatic Reference Counting(ARC) 作为一个编译工具，自动管理 Objective-C 对象。

简单地说，就是不再需要开发者使用 retain, release, autorelease 这些方法。

ARC 会在编译时期，添加内存管理代码，确保对象尽可能地存活。

事实上，它使用的内存管理方式与 MRC 一致。

规则

• 不能调用 dealloc，不能调用或者覆写 retain, release, retainCount, autorelease
  也不能使用 @selector(retain) 这样的形式去调用。
  可以覆写 dealloc，去处理 ARC 未能进行管理的对象，但不需要调用 [super dealloc]。
  Core Foundation 对象不受 ARC 管理，可继续使用 CFRetain, CFRelease 进行管理。

• 不能使用 NSAllocateObject 或 NSDeallocateObject
  可以使用 alloc 创建对象，运行期系统管理需要销毁的对象。

• 不能在 C 结构体中，使用对象指针
  创建 Objective-C 类去管理数据，而不是使用 struct。

• 转换 id 和 void * 需要特定规则

• 不能使用 NSAutoreleasePool 对象
  使用 @autoreleasepool{}

• 不需要使用 NSZone

• 存取方法名称不能以 new 开头

  // Won't work:
  @property NSString *newTitle;
  
  // Works:
  @property (getter=theNewTitle) NSString *newTitle;
  

生命周期修饰词

变量修饰词

• __strong 默认值，被修饰对象会一直存活到：没有强引用指向它
• __weak 不会影响引用计数，当没有指向的对象被销毁时，指针会被设置成 nil
• __unsafe_unretained 不保证修饰对象存活，当没有强引用时，也不会设置为 nil，即使对象被销毁，指针还是指向它
• __autoreleasing 主要用来修饰传递引用的参数
  常见的是传递 NSError 对象，返回后，NSError 对象会自动释放。

正确使用形式

ClassName * qualifier variableName;

其他形式在技术上来讲是错误的，但编译器“原谅”了它们。

当方法参数是个引用时，尤其需要注意，以下代码可以正常运行：

NSError *error;
BOOL OK = [myObject performOperationWithError:&error];
if (!OK) {
    // Report the error.
    // ...
}

然而，实际 NSError 对象是这样声明的

NSError * __strong e;

而其中的方法声明是

-(BOOL)performOperationWithError:(NSError * __autoreleasing *)error;

所以，编译器会重写代码：

NSError * __strong error;
NSError * __autoreleasing tmp = error;
BOOL OK = [myObject performOperationWithError:&tmp];
error = tmp;
if (!OK) {
    // Report the error.
    // ...
}

如果不希望编译器这样重写代码的话，可以将 NSError 对象声明成 __autoreleasing。

使用修饰词避免循环引用

使用 __weak

MyViewController *myController = [[MyViewController alloc] init];
// ...
MyViewController * __weak weakMyViewController = myController;
myController.completionHandler =  ^(NSInteger result) {
    // 添加 __strong，避免使用 weakMyViewController 时，它已经被释放
    MyViewController * __strong strongMyViewController = weakMyViewController;
    [strongMyViewController dismissViewControllerAnimated:YES completion:nil];
};

使用 __block，然后在 block 结束时，将引用的对象设为 nil。

MyViewController * __block myController = [[MyViewController alloc] init…];
// ...
myController.completionHandler =  ^(NSInteger result) {
    [myController dismissViewControllerAnimated:YES completion:nil];
    myController = nil;
};

使用 @autoreleasepool{} 管理自动释放池，比使用 NSAutoreleasePool 高效。

开发界面时，outlets 应该使用 weak 修饰。

栈上的变量，无论是 strong, weak 还是 autorelease，都默认初始化成 nil。

使用 -fobjc-arc 编译器标志来设置某个文件，使用 ARC 环境。
使用 -fno-objc-arc 编译器标志来禁止某个文件使用 ARC。

无缝桥接

• __bridge 在 Objective-C 和 Core Foundation 对象间不转换持有关系

• __bridge_retained 或 CFBridgingRetain 可让一个 Objective-C 指针转换成 Core Foundation 指针，并持有它。
  所以调用 CFRelease 或相关方法去释放它

• __bridge_transfer 或 CFBridgingRelease 将一个非 Objective-C 指针转换成 Objective-C 指针，并持有它。
  ARC 负责释放它

以下代码，很好地展示了无缝桥接的使用：

- (void)drawRect:(CGRect)rect {
    CGContextRef ctx = UIGraphicsGetCurrentContext();
    CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceGray();
    CGFloat locations[2] = {0.0, 1.0};
    NSMutableArray *colors = [NSMutableArray arrayWithObject:(id)[[UIColor darkGrayColor] CGColor]];
    [colors addObject:(id)[[UIColor lightGrayColor] CGColor]];
    CGGradientRef gradient = CGGradientCreateWithColors(colorSpace, (__bridge CFArrayRef)colors, locations);
    CGColorSpaceRelease(colorSpace);  // Release owned Core Foundation object.
    CGPoint startPoint = CGPointMake(0.0, 0.0);
    CGPoint endPoint = CGPointMake(CGRectGetMaxX(self.bounds), CGRectGetMaxY(self.bounds));
    CGContextDrawLinearGradient(ctx, gradient, startPoint, endPoint,
                                kCGGradientDrawsBeforeStartLocation | kCGGradientDrawsAfterEndLocation);
    CGGradientRelease(gradient);  // Release owned Core Foundation object.
}

要点

• 不能调用 retain, release, autorelease

• 不能调用 dealloc

• 不能使用 NSAutoreleasePool 对象
  取而代之的是 @autoreleasepool{}，它的执行效率是 NSAutoreleasePool 的6倍。

• ARC 需要将 [super init] 的结果赋值给 self。
  所以一般是这样写

  self = [super init];
  if (self) {
     ...
  }
  

• 不需要实现 retain 或 release 方法
  自定义 retain 或 release 会破坏弱指针。

目前 ARC 的效率已经足够高了，若发现问题，可以提交 bug。

• ARC 环境下，默认使用 strong 修饰符
• 不能在 C 语言结构体里使用 strong ids
  替代方式：使用 Objective-C 对象替代。

如果不行，就将 Objective-C 对象转换成 void* （使用 __unsafe_unretained 修饰）。

• 不能直接转换 id 和 void* (包括 Core Foundation)，需要使用无缝桥接

struct x { NSString * __unsafe_unretained S; int X; }

FAQ

blocks 在 ARC 下是如何工作的？

blocks 在它处于栈顶的时候工作，不需要调用 Block copy。

需要注意的是 NSString * __block myString 在 ARC 模式下，是会被持有的，而不是一个危险指针。

在 ARC 环境下，如何创建一个 C 语言数组？

示例代码：

// Note calloc() to get zero-filled memory.
__strong SomeClass **dynamicArray = (__strong SomeClass **)calloc(entries, sizeof(SomeClass *));
for (int i = 0; i < entries; i++) {
     dynamicArray[i] = [[SomeClass alloc] init];
}
 
// When you're done, set each entry to nil to tell ARC to release the object.
for (int i = 0; i < entries; i++) {
     dynamicArray[i] = nil;
}
free(dynamicArray);

需要注意的是：

• 有时需要添加 __strong SomeClass **，因为默认是 __autoreleasing SomeClass **
• 被分配的内存必须是 zero-filled
• 在释放数组时，必须将每个对象设置成 nil（无法使用 memset 或 bzero）
• 你应该要避免使用 memcpy 或 realloc

ARC 是否会比较慢

这跟如何使用有关系，但一般来说，不会慢。

编译器高效地减少无关的 ratain 或 release 调用，而且做了很多加速 Objective-C 运行的工作。

特别地，在 ARC 下，调用 “return a retain/autoreleased objec” 的对象，也不会每次都被放到自动释放池中。

可以在 debug 模式下，创建大量对象，让 reatain 和 release 不断被调用，可以观察到，使用的时间接近0。

ARC 是否支持 ObjC++ 模式？

支持。
可以将 strong / weak 对象放到类或容器里，ARC 编译器会把 retain / release 逻辑复制到“copy constructors and destructors” 中。

哪些类不支持弱引用？

NSATSTypesetter, NSColorSpace, NSFont, NSMenuView, NSParagraphStyle, NSSimpleHorizontalTypesetter, and NSTextView.

在这种情况下，声明属性，需要使用 assign 代替 weak；声明变量，需要使用 __unsafe_unretained。

当继承 NSCell 或其他使用 NSCopyObject 的类，需要额外做些什么？

不需要。

在 ARC 下，所有的复制方法仅仅复制实例变量。