iOS 内存管理

[TOC]

概述

引用计数

MRC - manual retain count

内存管理的思考方式

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

对象操作	Objective-C 方法
生成并持有对象	alloc/new/copy/mutableCopy 等方法
持有对象	retain 方法
释放对象	release 方法
废弃对象	dealloc 方法

问题

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

ARC

编译器的特性，不是运行时特性或者垃圾回收机制
ARC做的只不过实在代码编译时，自动的在合适的位置插入 retain/release 或者 autorelease

weak/unsafe_unretained/assign 区别

容易出的问题 --- 循环引用

delegate
block
timer

AutoRelease

问题1

MRC下，一个方法返回新创建的对象，如何释放

OC的内存管理机制中比较重要的一条规律是：谁申请，谁释放
考虑这种情况，如果一个方法需要返回一个新建的对象，该对象何时释放？

方法内部是不会写release来释放对象的，因为这样做会将对象立即释放而返回一个空对象；调用者也不会主动释放该对象的，因为调用者遵循“谁申请，谁释放”的原则。那么这个时候，就发生了内存泄露。

理解概念

类似 C 语言的自动变量

{
    int a;
}
// 超出变量的作用域，变量 a 被废弃，不再可访问

autorelease 会像 C语言的自动变量那样来对待对象实例。当超出其作用域时，对象实例的 release 实例方法被调用。

- (void)viewDidLoad {
    [super viewDidLoad];
    @autoreleasepool {
        NSString *str = [NSString stringWithFormat:@"sunnyxx"];
    }
    NSLog(@"%@", str); // Console: (null)
}

另外，同 C 语言不通的是，编程人员可以设定变量的作用域。

它可以暂时的保存某个对象（object），然后在内存池自己的排干（drain）的时候对其中的每个对象发送release消息

autorelase 生命周期

autorelease pool来避免频繁申请/释放内存（就是pool的作用了）

使用方法

autorelease可以通过NSAutoreleasePool创建实例

// MRC

NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

id obj = [NSObject new];
[obj autorelease];

[pool drain];   // 相当于 pool release

//注意，这里只是发送release消息，如果当时的引用计数（reference-counted）依然不为0，则该对象依然不会被释放。可以用该方法来保存某个对象，也要注意保存之后要释放该对象。

一个对象可以反复调用 autorelease 方法进入投一个池中，相应地，当池子被销毁时，该对象将会调用相同次数的 release 方法，并不会造成内存泄漏，但并不建议这么做
autorelease pool 对象不能 retain，不能 autorelease，所以 drain/release 方法可以直接释放内存。你应该在同一个上下文（调用创建这个池的同一个方法，函数或者循环体）中 drain 一个 autorelease pool。

// ARC 环境下

@autoreleasepool {

// Code benefitting from a local autorelease pool.

}
Ps : 官方文档说明, 使用@autoreleasepool这个block比NSAutoreleasePool更高效!并且在MRC环境下同样适用

注意事项

程序中至少存在一个自动释放池，否则 autoreleased 对象将不能对应收到 release 消息而导致内存泄漏
MRC下需要对象调用 autorelease 才会入池，ARC 则不需要
自动释放池可以嵌套使用

autorelease 应用

iOS 默认的 autorelease pool

//iOS program
int main(int argc, char * argv[]) {
    @autoreleasepool {
        return UIApplicationMain(argc, argv, nil, NSStringFromClass([AppDelegate class]));
    }
}

在 iPhone 项目中，大家会看到一个默认的Autorelease pool，程序开始时创建，程序退出时销毁，
按照对Autorelease的理解，岂不是所有autorelease pool里的对象在程序退出时才release，
这样跟内存泄露有什么区别？

答案是，对于每一个Runloop，系统会隐式创建一个Autorelease pool，这样所有的release pool会构成一个象CallStack一样的一个栈式结构，在每一个Runloop结束时，当前栈顶的Autorelease pool会被销毁，这样这个pool里的每个Object会被release。

runloop 与 autorelase

容器枚举器

使用容器的block版本的枚举器时，内部会自动添加一个AutoreleasePool：

[array enumerateObjectsUsingBlock:^(id obj, NSUInteger idx, BOOL *stop) {
// 这里被一个局部@autoreleasepool包围着
}];
当然，在普通for循环和for in循环中没有，所以，还是新版的block版本枚举器更加方便。for循环中遍历产生大量autorelease变量时，就需要手加局部AutoreleasePool咯。

什么时候需要自己手动创建autorelease pool

看苹果官方文档怎么说明 :

If you are writing a program that is not based on a UI framework, such as a command-line tool.

If you write a loop that creates many temporary objects.
You may use an autorelease pool block inside the loop to dispose of those objects before the next iteration. Using an autorelease pool block in the loop helps to reduce the maximum memory footprint of the application.

If you spawn a secondary thread.
You must create your own autorelease pool block as soon as the thread begins executing; otherwise, your application will leak objects.

编写不是基于UI framework的程序, 例如命令行项目
编写的循环创建了大量临时对象 -> 你需要在循环体内创建一个autorelease pool block并且在每次循环结束之前处理那些autoreleased对象. 在循环中使用autorelease pool block可以降低内存峰值
你创建了一个新线程,当线程开始执行的时候你必须立马创建一个autorelease pool block, 否则你的应用会造成内存泄露.

优化循环 Demo

- (void)loopManyManyTimesWithoutAutorelease
{
    for (int i=0; i<500000; i++) {
        NSString *str = [NSString stringWithFormat:@"autorelease pool %@",@(i)];
        NSLog(@"%@",str);
    }
}

- (void)loopManyManyTimesWithAutorelease
{
    for (int i=0; i<500000; i++) {
        @autoreleasepool {
            NSString *str = [NSString stringWithFormat:@"autorelease pool %@",@(i)];
            NSLog(@"%@",str);
        }
    }
}

使用 autorelease 注意事项

MRC / ARC 环境使用方式的区别
尽量避免对大的内存占用使用该方法
不要把大量循环操作放到同一个 autorelease pool 之中，会造成内存峰值的上升

高级

GNUstep @ http://gnustep.org

alloc/retain/release/dealloc 实现

alloc

struct obj_layout {
    NSUInteger retained;
}

+ (id) alloc
{
    int size = sizeof(struct obj_layout) + 对象大小;
    struct obj_layout *p = (struct obj_layout *)calloc(1,size);
    retain (id)(p+1);
}

retainCount


- (NSUInteger) retainCount
{
  return NSExtraRefCount(self) + 1;
}

inline NSUInteger
NSExtraRefCount(id anObject)
{
  return ((obj)anObject)[-1].retained;
}

retain

- (id) retain
{
  NSIncrementExtraRefCount(self);
}

inline void
NSIncrementExtraRefCount(id anObject)
{
    if (((obj)anObject)[-1].retained == UINT_MAX - 1)
    {
      [NSException raise: NSInternalInconsistencyException
        format: @"NSIncrementExtraRefCount() asked to increment too far"];
    }
    ((obj)anObject)[-1].retained++;
}

release

- (oneway void) release
{
    if (NSDecrementExtraRefCountWasZero(self))
    {
      [self dealloc];
    }
}

BOOL
NSDecrementExtraRefCountWasZero(id anObject)
{
    if (((obj)anObject)[-1].retained == 0)
    {
      return YES;
    }
    else
    {
      ((obj)anObject)[-1].retained--;
      return NO;
    }
  return NO;
}

dealloc

- (void) dealloc
{
  NSDeallocateObject (self);
}

inline void
NSDeallocateObject(id anObject)
{
    struct obj_layout *o = &((struct obj_layout) anObject)[-1];
    free(o)
}

苹果的实现

总结

通过内存块头部

少量代码即可完成。简单
能够统一管理引用计数内存块与对象用内存块

通过引用计数表

对象用内存块的分配无需考虑内存块头部
引用计数表各记录中存有内存块地址，可以从各个记录追溯到个对象的内存块

问题

RAC 出现以后 weak 修饰的变量在销毁后，会自动变成 nil，是怎么做到的

从 weak 表获取废弃对象地址为键值的记录
将记录里面所有变量，赋值为 nil
从 weak 表中删除该记录

参考

黑幕背后的Autorelease
iOS中autorelease的那些事儿