iOS 内存管理

总结自 美团点评技术沙龙 Online 第4期

内存管理的几种方式

• 显式内存释放（C：-free、C++：-delete）
  • 内存可能被提前释放，（悬停指针 dangling pointer）
  • 内存永远无法释放（内存泄露）
• 基于引用计数（smart pointer、Objective-C）
• 垃圾回收（Java、C#）

MRC（Mannul Reference Counting）

也叫 MRR（Mannul Retain-Release）

• 严格遵守引用计数规则，保持 retain 和 release 之间的平衡
• 对象创建后，retain count 为1
• retain count 为正，对象继续存或
• retain count 降为0，对象被销毁

规则：

• 自己生成的对象，自己持有（alloc，allocWithZone:，copy，copyWithZone:，mutableCopy，mutableCopyWithZone)
• 非自己生成的对象，自己也可以持有（retain）
• 不需要自己持有的对象，必须释放它（release，autorelease）
• 非自己持有的对象无法释放

MRC 循环引用（retain cycle）

对象间直接或间接相互持有引用，自己持有自己也算。
解决方法：

• assign 修饰属性，需要的地方手动置为 nil
• block 中的循环引用，使用 __block 修饰对象

MRC 释放时机的问题

有时在创建一个对象之后，无法确定在什么时候释放，比如一个方法要返回一个对象，那么在方法内产生的 retain count 要在什么时候 release 是未知的。

- (NSObject *)object
{
  NSObject *o = [[NSObject alloc] init]; // 生成对象，retain count +1
  //方法执行完毕后要减去上面的 retain count，但是又不能在这里释放
  //[o release]; 
  return o;
}

针对这个问题，OC 引入了 Autorelease。

Autorelease

延迟释放对象。
方法：

• 手动调用 autorelease 方法
• 工厂方法返回值是一般都是 autorelease 的

NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
NSString *string;
char* cString = "Hello";
string = [NSString stringWithUTF8String:cString];
NSObject *obj = [[[NSObject alloc] init] autorelease];
[pool release];

autorelease 对象不会立即释放，会被注册到 autoreleasepool 中，在 pool 释放时，pool 中的对象会自动调用 release。

在 iOS 应用程序的 main 函数中，由系统创建了一个 autoreleasepool，在主线程的 Runloop 结束时会自动释放 autoreleasepool。

好处：减少内存峰值

for (int i = 0; i < 100; i++) {
      NSError *error;
      NSString *fileContents = [NSString stringWithContentsOfURL:urlArray[i] encoding:NSUTF8StringEncoding error:&error];
}

由于工厂方法生成的对象一般都是 autorelease 的，所以这里创建的100个都不会立即被释放，会等到 autoreleasepool 释放时才会释放，这样的话，会真用很多内存，造成内存峰值飙升。
解决方法是将循环体的代码放到 autoreleasepool 中。

for (int i = 0; i < 100; i++) {
      NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
      NSError *error;
      NSString *fileContents = [NSString stringWithContentsOfURL:urlArray[i] encoding:NSUTF8StringEncoding error:&error];
      [pool release];
}

这样，每次有工厂方法生成的 autorelease 对象都会被注册到我们自己创建的 autreleasepool 中，在每次循环结束时释放掉 autoreleasepool，同时也会是放掉 pool 中的 autorelease 对象。

相关点：

• Run loop 会在每次 loop 到尾部时销毁 Autorelease pool。
• GCD 的 dispatched blocks 会在一个 Autorelease Pool 的上下文中执行，这个 Autorelease Pool 不时的就被销毁了（依赖于实现细节）。NSOperationQueue 也类似。
• 其他线程则会各自对自己的 Autorelease Pool 的生命周期负责。

MRC 缺点

• 忘记释放，内存泄露
• 提前释放，悬停指针

为了解决这些问题，Apple 在 iOS4.3 之后引入 ARC。iOS5.0 之后引入 weak。

---

ARC （Automatic Reference Counting）

ARC 是 OBjective-C 编译器的特性，而不是运行时特性或者垃圾回收机制。ARC 所做的只不过是在代码编译时，由编译子帮你自动在合适的位置插入 retain/release 或 autorelease，所以本质和 MRC 是一样的。

ARC 中可以 retain 的对象指针

• block 指针
• Objective-C 的对象指针
• 用 __attribute__((NSObject)) 标记的对象

编译器会在调用如下方法（方法族）时插入 retain

alloc、new、copy、mutableCopy、init

ARC 环境下的关键字

• __strong
  持有对象
• __weak
  不持有对象，对象没有强引用时会置为 nil
• __unsafe_unretained
  不持有对象，对象没有强引用时不会置为 nil
  可以在 C 结构体里使用 OC 对象

struct x {
        // 这里如果使用__strong 或 __weak，编译器会报错
        NSString __unsafe_unretained *s;
        int x;
}

• __autoreleaseing
  表明传引用的参数(id *)在返回时是 autorelease 的
  效果等同 MRC 下的 autorelease 方法

for (int i = 0; i < 100; i++) {
        @autoreleasepool {
            id __autoreleaseing obj = [[NSObject alloc] init];
            NSError *error;
            // 实际上在 ARC 环境下，工厂方法已经不在返回 autorelease 对象了。
            NSString *fileContents = [NSString stringWithContentsOfURL:urlArray[i] encoding:NSUTF8StringEncoding error:&error];
        }
}

ARC 循环引用

• property: weak
• block：__weak，@weakify & @strongify

---

Core Foundation 的内存管理

相关方法

CFRetain、CFRelease、CFAutorelease、CCGetRetainCount

规则

• The Create - Rule
  含有"Create"、"Copy"的方法创建的对象，需要手动释放。

CFTimeZoneRef CFTimeZoneCreateWithTimeIntervalFromGMT(CFAllocator allocator, CFTimeInterval ti);
CFDictionaryRef CFTimeZoneCopyAbbreviationDictionary(void);
CFBundleRef CFBundleCreate(CFAllocator allocator, CFURLRef bundleURL);

• The Get - Rule
  不含有则不需要手动释放

CFStringRef CFAttributedStringGetString(CFAttributedStringRef aStr);

• Toll - Free Bridging
  • __bridge：只是声明类型转变，内存管理所有权不变；
  • __bridge_retained：指针类型转变，同时内存管理所有权由 Objective-C 交由 Core Foundation 处理，即由 ARC 变为 MRC；
  • __bridge_transfer：指针类型转变，同事内存管理所有权由 Core Foundation 交由 Objective-C 处理，即 MRC 变为 ARC；

// NSString 转为 CFString ，内存管理所有权不变，依然是 ARC
CFStringRef s = (__bridge CFStringRef)[[NSString alloc] initWithFormat:@"Hello, %@!", name];

NSString *s1 = [[NSString alloc] initWithFormat:@"Hello, %@!", name];
// NSString 转为 CFString，且内存管理所有权改变， ARC 变为 MRC
CFStringRef s2 = (__bridge_retained CFStringRef)s1;
// or CFStringRef s2 = (CFStringRef)CFBridgingRetain(s1);
...
// 手动释放
CFRelease(s2);

CFStringRef result = CFURLCreateStringByAddingPercentEscapes(...);
// CFString 转 NSString，内存管理所有权改变， MRC 变 ARC
NSStrig *s = (__bridge_transfer)result;
// or NSStrig *s = (NSString *)CFBridgingRelease(result);
// 虽然创建方法含有"Create"，但是无需手动释放
return s;

---

思考

1、为什么 weak 变量会自动置为 nil ？

OC 的运行时在运行期会维护一个 weak 表（hash 表），会以对象（被 weak 指针指向的对象）的地址 作为key，以 weak 对象地址作为value，一个key可以注册多个value。
如：__weak typeof(self) self_weak = self;
以 self 的地址作为 key，self_weak 的地址作为 value；

一个 weak 对象引用计数变为0后的执行过程：

• objc_release 此时引用计数变为0，执行 dealloc
• _objc_rootDealloc
• object_dispose
• objc_destructInstance
• objc_clear_deallocating
  最后一个方法，会从 weak 表里获取释放对象的地址作为键值的所有记录，将记录里面 value 对应的变量地址，赋值为 nil，然后删除这条记录。

2、AutoreleasePool 是怎么将 Autorelease 对象注册到 pool 中和从 pool 中释放？

注册时会调用 push 方法，释放时则会调用 pop 方法

void *objc_autoreleasePoolPush(void) {
    return AutoreleasePoolPage::push();
}

void objc_autoreleasePoolPop(void *ctxt) {
    AutoreleasePoolPage::pop(ctxt);
}

AutoreleasePool 类内部实现是一个双向链表。

class AutoreleasePoolPage {
  magic_t const magic;
  id *next;
  pthread_t const thread;
  AutoreleasePoolPage *const parent; 
  AutoreleasePoolPage *child;
  uint32_t const depth;
  uint32_t const hiwat;
}

AutoreleasePool 有一个哨兵对象（POOL_SENTINEL）用来标记嵌套关系，当其中的一个对象释放后遇到哨兵对象，就意味着当前的 AutoreleasePool 已经释放完毕了，接下来继续释放的对象就是另外一个 AutoreleasePool 中的对象了。

3、为什么 nonatomic 属性会导致 crash ？

在给一个属性赋值时，运行时执行的代码类似如下代码：

static inline void reallySetProperty(id self, SEL _cmd, id newValue, ptrdiff_t offset, bool atomic)
{
    id oldValue;
    id *slot = (id *) ((char *)self + offset);
    if (!atomic) {
        oldValue = *slot;
        *slot = newValue;
    } else {
        spinlock_t & slotlock = PropertyLocks[slot];
        slotlock.lock();
        oldValue = *slot;
        *slot = newValue;
        slotlock.unlock();
    }
    objc_release(oldValue);
}

在最后会释放旧值，这时候就会存在问题。在多线程情况下，nonatomic 属性不是线程安全的，所以会存在两个线程同时修改属性的情况，假设有两个线程同时修改属性，这两个线程中的 oldValue 是指向同一块内存的，在线程1第一次释放后，这块内存会被重新分配，此时线程2再次释放，就会将新分配的变量释放掉，之后若在别的地方用到了这个变量，就可能会发生 crash。

4、Objective-C 里的数组，放进去的元素都会被持有吗？如果被数组持有，怎样做一个不吃又元素的数组？

5、NSDictionary 的 key 和 value 的内存语义是怎样的？

6、在 ARC 环境下，函数的返回值已经不再使用 Autorelease 机制了，它是怎么实现的？但是如果调用方是 MRC 环境，ARC 下面的函数返回值会自动启动 Autorelease，这又是怎么实现的？

7、Toll-Free Bridging 是怎么实现的？什么样的 Core Foundation 和 Foundation 对象才能做到 Toll-Free Bridging？

8、如果一个对象持有一个 block，在 block 里面使用到了对象的一个实例变量，会形成循环引用吗？如果以一个临时变量引用实例变量，在 block 中使用这个临时变量又会怎样？

9、对象的引用计数存在对象的内存布局里还是全局的引用计数变里？为什么？两种方式各有什么优缺点？

---

Q&A

1. 静态分析工具：Xcode、sonar

相关参考资料

• 《Objective-C 高级编程 iOS 与 OS X 多线程和内存管理》
• 《垃圾回收算法手册》
• Objective-C Automatic Reference Counting (ARC)
• Advanced Memory Management Programming Guide
• Transitioning to ARC Release Notes
• Memory Management Programming Guide for Core Foundation
• 自动释放池的前世今生 ---- 深入解析 autoreleasepool