读书笔记 | Objective-C高级编程-引用计数

发表于

OBJC 第一章 引用计数 读书笔记，知识结构基本按照课本章节安排，也加入了自己的一些理解和注意事项，只要是供自己日后快速回顾使用。

什么是自动引用计数

让编译器进行内存管理，编译器在合适地方自动进行retain/release（包括运行时）

内存管理/引用计数

内存管理的4条基本原则：

  • 自己生成的对象, 自己持有.

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

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

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

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

  • 想持有对象，则如下：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
      id obj = [NSMutableArray array]; // 取得对象存在, 但自己并不持有对象
      [obj retain];  //持有对象
      [obj release]; // 释放对象
    //原因：
    //allocObject 返回生成并持有的对象
    - (id)allocObject
    {
      id obj = [[NSObject alloc] init];
      return obj;
    }
    //object 返回生成的对象,对象存在但不持有
    - (id)Object
    {
      id obj = [[NSObject alloc] init];
      [obj autorelease];//autorelease 可以使对象超出指定的生存范围时自动并正确的释放（调用release）
      return obj;
    }

即：以init名称开始的方法直接返回对象, 不注册到autoreleasepool上.

内存管理明白几个名词：

  • 生成并持有对象 ：alloc（XXX）、new（XXX）、copy（XXX）、mutableCopy（XXX）等
  • 持有对象 ：retain
  • 释放对象 ：release
  • 废弃对象 ：dealloc

实质为NSObject的对象管理

upload successful

alloc/retain/release/dealloc 具体实现：

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

GNUstep实现：

alloc的调用栈：alloc → allocWithZone → NSAllocObject

upload successful

因此我们在alloc/retain/release/dealloc，都会通过((struct obj_layout )obj)[-1].retained 来进行引用计数的管理。通过&((struct obj_layout )obj)[-1]获取实际的对象地址。

苹果实现：

alloc的调用栈：alloc → allocWithZone → class_createInstance → calloc
与GNUstep基本一致， class_createInstance → calloc 为运行时方法，最后会调用到CFRuntime的__CFDoExternRefOperation方法进行分发

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#define EXTERN_TABLE_IDX(O) (((uintptr_t)(O) >> 8) & 0x7)
// we disguise pointers so that programs like 'leaks' forget about these references
#define DISGUISE(O) (~(uintptr_t)(O))
CF_EXPORT uintptr_t __CFDoExternRefOperation(uintptr_t op, id obj) {
    if (nil == obj) HALT;
    uintptr_t idx = EXTERN_TABLE_IDX(obj);
    uintptr_t disguised = DISGUISE(obj);
    CFLock_t *lock = &__NSRetainCounters[idx].lock;
    CFBasicHashRef table = __NSRetainCounters[idx].table;
    uintptr_t count;
    switch (op) {
    case 300:   // increment
    case 350:   // increment, no event
        __CFLock(lock);
        CFBasicHashAddValue(table, disguised, disguised);
        __CFUnlock(lock);
        if (__CFOASafe && op != 350) __CFRecordAllocationEvent(__kCFObjectRetainedEvent, obj, 0, 0, NULL);
        return (uintptr_t)obj;
    case 400:   // decrement
        if (__CFOASafe) __CFRecordAllocationEvent(__kCFObjectReleasedEvent, obj, 0, 0, NULL);
    case 450:   // decrement, no event
        __CFLock(lock);
        count = (uintptr_t)CFBasicHashRemoveValue(table, disguised);
        __CFUnlock(lock);
        return 0 == count;
    case 500:
        __CFLock(lock);
        count = (uintptr_t)CFBasicHashGetCountOfKey(table, disguised);
        __CFUnlock(lock);
        return count;
    }
    return 0;
}

alloc => 调用class_createInstance(calloc)分配内存 => 设置isa指针和成员变量初始值(0) => 在引用计数表中添加纪录，并将引用计数值置为1

dealloc => 删除引用计数表中的对应记录 => free内存块

upload successful

GNUstop的好处 :

少量代码即可完成.

能够统一管理引用计数用内存块与对象用内存块.

苹果的好处 :

对象用内存块的分配无需考虑内存块头部.

引用计数表各记录中存有内存块地址, 可从各个记录追溯到各对象的内存块.

autorelease

概述

  • autorelease 像ARC，实际上类似局部变量的特性。其作用：
    • 1、生成并持有NSAutoreleasePool对象;
    • 2、调用已分配对象的autorelease实例方法
    • 3、放弃NSAutoreleasePool对象

在Cocoa框架中，相当于主循环的NSRunLoop或者其他程序可执行的地方，对NSAutoreleasePool对象进行生成、持有和废弃处理。

upload successful

upload successful

autorelease实现：

GNUStep：通过连续列表实现；在废弃时，遍历NSAutoreleasePool对象数组，进行release

1
2
3
4
- (id)autorelease
{
  [NSAutoreleasePool addObject:self];
}

苹果实现：功能与GNUstep类似，

upload successful

upload successful

调试：iOS：[NSAutoreleasePool showPools]

运行时函数：__objc_autoReleasePoolPrint();

ARC规则

文件的编译属性设置：-fobjc-arc 或 -fno-objc-arc

修饰符

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

  • __weak ：

    1
    2
    3
    4
    5
    6
    //warning：自己生成的对象，自己不持有，会立即释放
    id __weak obj = [[NSObject alloc] init];
    //fix
    id __strong obj2 = [[NSObject alloc] init];
    id __weak obj3 ＝ obj2

  • unsafe_unretained （同weak iOS4 以下替代weak）

  • __autoreleasing

upload successful

不以alloc/new/copy/mutableCopy开头的方法(init系列方法除外)返回的对象将自动注册
id的指针或对象的指针在没有显示指定时会被附加上autoreleasing修饰符。
对象指针型赋值时，所有权修饰符必须一致。
id autorelease *obj 会被初始化为nil，而__strong修饰符就不会。

upload successful

ARC 规则：

其中id 和 “void *”称为 Toll-Free Bridge（CF对象与OC对象的转换不需要使用额外的CPU资源）

upload successful

  • bridge转换
    单纯地转换, 不安全.

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

  • __bridge_retained转换（与retain类似）
    可使要转换赋值的变量也持有所赋值的对象, 即

    1
    2
    3
    4
    id obj = [[NSObject alloc] init];
    void *p = (__bridge_retained void *)obj;
    // 相当于加上 [(id)p retain];
    则obj与p同时持有该对象

  • bridge_transfer转换（与release类似）
    与    bridge_retained相反, 被转换的变量所持有的对象在该变量被赋值给转换目标变量后随之释放.

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

属性：

upload successful

ARC 实现

  • __strong:

    赋值分为两种情况：
    alloc/new/copy/mutableCopy系列：涉及的函数有：objc_msgSend、objc_release和objc_retain、objc_autorelease

    object系列：涉及的函数：objc_msgSend Objc_autoreleaseReturnValue, objc_retainAutoreleasedReturnValue 优化

upload successful

  • weak
    规则：
    若附有weak修饰符的变量所引用的对象被废弃, 则将nil赋值给该变量.

    使用附有__weak修饰符的变量, 即是使用注册到autoreleasepool中的对象.

upload successful

upload successful

大量Weak变量会消耗CPU资源，只有在需要weak的地方才进行weak

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
{
id __weak obj1 = obj;// obj Strong
}
//实际过程
id obj1;
objc_initWeak(&obj1, obj);
objc_destroyWeak(&obj1);
//也可转换为以下代码
id obj1;
obj1 = 0;
objc_storeWeak(&obj1, obj);
objc_storeWeak(&obj1, 0);
{
    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);
// objc_loadWeakRetained函数取出附有__weak修饰符变量所引用对象并retain
{
id __weak obj1 = [[NSObject alloc] init];//Warning
}
//消除warning，void转换
（void）[[NSObject alloc] init]
//与赋值给__unsafe_unretained修饰的变量完全相同
//另外能立即调用被释放对象的方法
（void）[[[NSObject alloc] init] hash]

weak变量访问所引用的对象几次, 对象就被注册到autoreleasepool里几次，可以通过strong对其强持有，则可以使其只注册一次。

文中还提到一个黑魔法,allowsWeakRefenrence, retainWeakRefenrence;后续再补充验证是否可用

  • __autorealse的实现：

将对象赋值给附有__autoreleasing修饰符的变量等同于MRC下调用对象的autorelease方法.

1
2
3
4
5
6
7
8
9
@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);

那么调用alloc/new/copy/mutableCopy以外的方法会怎样呢?

1
2
3
4
5
6
7
8
9
@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);

可见注册autorelease的方法没有改变, 仍是objc_autorelease函数

如何获取引用计数值

  • 获取引用数值的函数

uinptr_t _objc_rootRetainCount(id obj)
retainCount计数不准确。

个人不建议通过查看引用计数来进行内存方面的管理

总结

Effective OC 中 关于引用计数的注意事项，正好这里有总结

  • 避免循环引用(使用__weak修饰符)-
  • 遵循ARC方法命名规则
  • 适时清空指针(赋值nil即可, 避免野指针错误)
  • 如用到Core Foundation对象, 则在dealloc方法中释放
  • 在dealloc方法中只释放引用并移除监听(不能在dealloc中开启异步任务)
  • 对于内存开销较大的资源, 如file descriptor, socket, 大块内存等应在
  • 不需要使用的时候调用close方法释放掉而不是在dealloc中处理.
  • 适当使用@autoreleasepool block来降低内存峰值
  • 必要时开启”僵尸对象”调试内存管理问题

参考

http://www.jianshu.com/p/3fcdd5f492da