《Objective-C 高级编程》引用计数笔记摘要

内存管理 / 引用计数

内存管理的思考方式

自己生成的对象，自己持有。
非自己生成的对象，自己也能持有。
不再需要自己持有的对象时释放。
非自己持有的对象无法释放。

NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
// 发生异常
[pool autorelease];
/*
通常在使用 OC，也就是 Foundation 框架时，无论调用哪一个对象的autorelease实例方法，实现上调用的都是 NSObject 类的 autorelease 实例方法。但是对于NSAutoreleasePool 类，autorelease方法已被该类重载，因此运行时就会出错。  
*/

ARC规则

__weak 修饰的变量需要注册到 autoreleasepool 对象中

id __weak obj1 = obj0;
NSLog(@"class=%@", [obj1 class]);

// 同上面等价
id __weak obj1 = obj0;
id __autoreleasing tmp = obj1;
NSLog(@"class=%@", [tmp class]);

/*
Q: 为什么在访问附有 __weak 修饰符的变量时必须访问注册到 autoreleasepool 的对象呢？
A: 因为 __weak 只持有对象的弱引用，而在访问引用对象的过程中，该对象有可能被废弃。注册到 autoreleasepool 中能确保对象在 pool 块结束之前存在。
*/

对象的指针和 id 指针：NSObject **obj，id *obj

对象 id obj 等价于 id __strong obj。
id 的指针 id *obj 等价于 id __autoreleasing *obj。
对象的指针 NSObject **obj 等价于 NSObject *__autoreleasing *obj。 

上面这些是默认行为，可以手动修改。如 id *obj 默认是 id __autoreleasing *obj，可以改成 id __strong *obj。
  
像这样，id 的指针或对象的指针在没有显式指定时会被附加上 __autoreleasing 修饰符。
  
**赋值给对象指针时，所有权修饰符必须一致。**

// 默认就是 __strong
NSerror *error = nil;
// 下面代码会产生编译错误
// NSError **pError = &error;
// 正确写法
NSError * __strong *pError = &error;

// __weak
NSError __weak *error = nil;
NSError * __weak *pError = &error;
  
// __unsafe_unretained
NSError * __unsafe_unretained *unsafeError = nil;
NSError * __unsafe_unretained *pUnsafeError = &unsafeError;

NSError *error = nil;
BOOL result = [obj performOperationWithError:&error];

// 为什么上面没有编译报错呢？因为编译器自动将源码转成了下面形式。
NSError * __strong *error = nil;
NSError * __autoreleasing *tmp = error;
BOOL result = [obj performOperationWithError:&tmp];
error = tmp;

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

对象型变量不能作为 C 语言结构体的成员。要把对象型变量加入到结构体成员中，需要强制转换为 void * 或者 __unsafe_unretained 修饰符。

struct Data {
  NSMutableArray __unsafe_unretained *array;
}

显示转换 id 和 void *。( __bridge_retained / __bridge_transfer )

/* ARC 无效时，id 和 void * 互转没问题 */
// id 转 void *
id obj = [[NSObject alloc] init];
void * p = obj;
// 更进一步
id o = p;
[o release];

/* 在 ARC 有效时，上述互转会编译错误 */
/* 如果想单纯地赋值，可以使用 __bridge，它不改变对象的持有状况。 */
// ARC 有效
id obj = [[NSObject alloc] init];
// 转换为 void * 的__bridge 安全性低，类似 __unsafe_unretained
void *p = (__bridge void *)obj;
id o = (__bridge id)p;

/* __bridge_retained：使赋值的对象也持有被赋值的对象 */
/* ARC 有效 */ 
id obj = [[NSObject alloc] init];
void *p = (__bridge_retained void *)obj;
/* ARC 无效 */
// __bridge_retained 转换变为了 retain。变量 obj 和变量 p 同时持有对象。
id obj = [[NSObject alloc] init];
void *p = obj;
[(id)p retain];

/* __bridge_transfer：与 __bridge_retained 相反，被转换的变量所持有的对象在被赋值给目标变量后随之释放。 */
/* ARC 有效时 */
id obj = (__bridge_transfer id)p;
/* ARC 无效时 */
id obj = (id)p;
[obj retain];
[(id)p release];

// (__bridge_retained void *)obj, (__bridge_transfer id)p.
/* __bridge_retained 与 __bridge_transfer 在 Foundation 与 CoreFoundation 中用得比较多 */
CFMutableArrayRef cfObj = (__bridge_retained CFMutableArrayRef)obj;

CFMutableArrayRef cfObject = NULL;
{
  id obj = [[NSMutableArray alloc] init];
  // cfObject 强引用 obj 持有的对象。CFBridgingRetain 与 __bridge_retained 等价
  // 如果是 __bridge，则不会改变持有状况，这里就是 cfObject 不会强引用。
  cfObject = CFBridgingRetain(obj);
  CFShow(cfObject);
  // retain count = 2
  printf("retain count = %d/n", CFGetRetainCount(cfObject));
}
// retain count = 1
printf("retain count after the scope = %d/n", CFGetRetainCount(cfObject));
CFRelease(cfObejct);

/*
    需要时刻注意在使用 CFBridgingRetain / CFBridgingRelease 或者 __bridge_retained / __bridge_transfer 转换时的内存管理。
*/

属性

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

ARC 的实现（参考：objc4 源码）

__strong 修饰符

id __strong obj = [NSMutableArray array]; 
/* 编译器的模拟代码 */
id obj = objc_msgSend(NSMutableArray, @selector(array));
objc_retainAutoreleasedReturnValue(objc);
objc_release(obj);

/*
objc_retainAutoreleasedReturnValue 函数与 objc_autoreleaseReturnValue 函数是成对的。
在调用 array 类方法后，由编译器插入该函数。
*/

+ (id)array {
  return [[NSMutableArray alloc] init];
}

/* 编译器的模拟代码 */
+ (id)array {
  id obj = objc_msgSend(NSMutableArray, @selector(alloc));
  objc_msgSend(obj, @selector(init));
  return objc_autoreleaseReturnValue(obj);
}  

/*
objc_autoreleaseReturnValue 函数返回的对象原本应该注册到 autoreleasepool 中，再从 pool 中获取对象。
但是通过 objc_retainAutoreleasedReturnValue 函数与 objc_autoreleaseReturnValue 函数实现了最优化，不需要注册到 pool 中，直接返回了对象。
*/

__weak 修饰符

// 假设变量 obj 附加 __strong 修饰符，且对象被赋值。
id __weak obj1 = obj;

/* 编译器的模拟代码 */
id obj1;
// 初始化由 __weak 修饰的 obj1 变量。
objc_initWeak(&obj1, obj);
// 在作用域结束时释放变量。
objc_destroyWeak(&obj1);

/* 上面的代码又等价于下面的代码 */
id obj1;
// 1. objc_initWeak(&obj1, obj);
obj1 = 0;
// 把 obj 作为 key，将 obj1 的地址注册到 weak 表中。当有多个 __weak 变量时，一个键值可注册多个变量的地址。
objc_storeWeak(&obj1, obj);
// 2. objc_destroyWeak(&obj1);
// 当 key 是 0 的时候，把变量的地址从 weak 表中移除。
objc_storeWeak(&obj1, 0);

程序是如何废弃谁都不持有的对象的呢

对象通过 objc_release 释放。

objc_release
因为引用计数为 0，所以执行 dealloc
_objc_rootDealloc
object_dispose
objc_destructInstance
objc_clear_deallocating

objc_clear_deallocating 函数的动作如下

从 weak 表中获取废弃对象的地址为键值的记录（被 __weak 修饰的所有变量）。
将包含在记录中的所有附有 __weak 修饰符的变量的地址，赋值为 nil。
从 weak 表中删除该记录。
从引用计数表中删除废弃对象的地址为键值的记录。

从以上步骤可知，如果大量使用附有 __weak 修饰符的变量，则会消耗相应的 CPU 资源。一般只在避免循环引用时使用 __weak 修饰符。

id __weak obj = [[NSObject alloc] init]; 内部发生了什么

// 会被立即释放，所以 obj 是 nil。
id __weak obj = [[NSObject alloc] init];

/* 编译器的模拟代码 */
id obj;
id tmp = objc_msgSend(NSObject, @selector(alloc));
objc_msgSend(tmp, @selector(init));
objc_initWeak(&obj, tmp);
objc_release(tmp);
objc_destroyWeak(&obj);

/*
虽然自己生成并持有的对象通过 init_Weak 函数被赋值给附有 __weak 修饰符的变量中，但编译器判断其没有持有者，所以该对象通过 objc_release 函数被释放和废弃。
这样一来，nil 就会被赋值给 obj 变量。
*/

id __unsafe_unretained obj = [[NSObject alloc] init]; 与 id weak obj =[[NSObject alloc] init]; 类似。对象会被立即释放，但是不会置为 nil，会产生悬垂指针赋值给 obj。

使用 __weak 修饰的变量，即是使用注册到 autoreleasepool 中的对象

{
  id __weak obj1 = obj;
  NSLog(@"%@", obj1);
}

/* 编译器的模拟代码 */
id obj1;
objc_initWeak(&obj1, obj);
id tmp = objc_loadWeakRetained(&obj1);
objc_autorelease(tmp);
NSLog(@"%@", tmp);
objc_destroyWeak(&obj1);

与被赋值时相比，在使用附有 __weak 修饰符变量的情形下，增加了 objc_loadWeakRetained 函数和 objc_destroyWeak 函数的调用。这些函数的动作如下：

objc_loadWeakRetained 函数取出 __weak 修饰的变量所引用的对象并 retain。
objc_autorelease 函数将该对象注册到 autoreleasepool 中。

如果大量使用 __weak 修饰的变量，注册到 autoreleasepool 中的对象也会大量增加，因此使用 __weak 修饰的变量时，最好先暂时赋值给 __strong 修饰的变量再使用。

// 变量 obj1 所赋值的对象在 autoreleasepool 中注册了 5 次。
{
  id __weak obj1 = obj;
  NSLog(@"1 %@", obj1);
  NSLog(@"2 %@", obj1);
  NSLog(@"3 %@", obj1);
  NSLog(@"4 %@", obj1);
  NSLog(@"5 %@", obj1);
}

// 只在 autoreleasepool 中注册了 1 次。
{
  id __weak obj1 = obj;
  id tmp = obj1;
  NSLog(@"1 %@", tmp);
  NSLog(@"2 %@", tmp);
  NSLog(@"3 %@", tmp);
  NSLog(@"4 %@", tmp);
  NSLog(@"5 %@", tmp);
}

不能使用 __weak 修饰符的类

NSMachPort 类就是不支持 __weak 修饰符的类。这些类重写了 retain / release 并实现该类独自的引用计数机制。

/*
不支持 __weak 修饰符的类，其类声明中附加了 "__attribute__((objc_arc_weak_reference_unavailable))" 这一属性，同时定义了 NS_AUTOMATED_REFCOUNT_WEAK_UNAVAILABLE。
*/

NS_AUTOMATED_REFCOUNT_WEAK_UNAVAILABLE 
@interface NSMachPort : NSPort {
    @private
    id _delegate;
    NSUInteger _flags;
    uint32_t _machPort;
    NSUInteger _reserved;
}
...

allowsWeakReference / retainWeakReference 方法

@interface MyObject : NSObject

{
    NSUInteger count;
}

@end

#import "MyObject.h"

@implementation MyObject

- (id)init {
    self = [super init];
    return self;
}

// 如果返回 NO，那么将对象赋值给 __weak修饰的变量时运行就会直接报错。
- (BOOL)allowsWeakReference {
    return NO;
}

// 当返回 NO，那么将对象赋值给 __weak修饰的变量时，返回 nil。
- (BOOL)retainWeakReference {
    if (++count > 3) {
        return NO;
    }
    return [super retainWeakReference];
}

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        id __strong obj = [[MyObject alloc] init];
      // 如果 - (BOOL)allowsWeakReference 返回NO，则运行时报错。
        id __weak o = obj;
      /* 1~3 有值 */
        NSLog(@"1 %@", o);
        NSLog(@"2 %@", o);
        NSLog(@"3 %@", o);
      // 4 (null)
        NSLog(@"4 %@", o);
      // 5 (null)
        NSLog(@"5 %@", o);        
    }
}

@end

__autoreleasing 修饰符

/* id __autoreleasing obj = [[NSObject alloc] init]; */
@autoreleasepool {
  id __autoreleasing obj = [[NSObject alloc] init];  
}

/* 编译器的模拟代码 */
id pool = objc_autoreleasePoolPush();
id obj = objc_msgSend(NSObject, @selector(alloc));
objc_msgSend(obj, @selector(init));
objc_autorelease(obj);
objc_autoreleasePoolPop(pool);

/* id __autoreleasing obj = [NSMutableArray array]; */
@autoreleasepool {
  id __autoreleasing obj = [NSMutableArray array];  
}

/* 编译器的模拟代码 */
id pool = objc_autoreleasePoolPush();
id obj = objc_msgSend(NSMutableArray, @selector(array));
objc_retainAutoreleasedReturnValue(obj);
objc_autorelease(obj);
objc_autoreleasePoolPop(pool);

《Objective-C 高级编程》引用计数 笔记摘要