前言

比较晚入坑iOS的同学大多没怎么使用过MRC（Manual Reference Counting），直接享受了ARC的便利，ARC（Automatic Reference Counting）从Xcode4引入，由于ARC下禁止直接调用retain、release、autorelease等函数，甚至不需要了解autorelease这些函数就能很好的进行iOS开发。然而，为了知其所以然，还是有必要了解一下底层的原理。

一、 概述

首先明确一点，ARC和Autorelease没有直接的联系，在MRC时代就存在Autorelease：
ARC：代替手动添加内存管理函数进行人工内存管理（retain、release、autorelease），编译阶段自动的在需要持有对象时插入retain函数、需要释放时插入release函数（就是这么智能）；
Autorelease：向一个对象发送延迟释放信息，使得这个对象可以在作用域意外范围被使用；典型的例子就是将一个对象作为返回值给调用者，如果不延迟释放，这个返回值在出了所在函数范围就被立即释放，调用者拿到的永远是nil，因为iOS的内存遵循谁申请谁释放的原则，当向一个对象发送了autorelease消息，实际上就是将该对象放入autoreleasePool池子动，等到延迟到适当的时机（通常是在NSRunloop即将进入休眠或者退出时）进行释放（对池子中的每个对象发送release消息）。

二、 底层实现

大家都知道获取一个NSMutableArray实例对象有好多种方式：如[NSMutableArray new]或者[NSMutableArray array]。
a. iOS很特别的一点就是用函数名字了表明内存管理的方式(包含alloc、retain、new、copy、mutablecopy等关键字的函数需要申请者负责释放该实例对象)，而后者不包含上述关键字的函数不需要调用者负责该对象的释放，所以其实上面方法后者不要调用者释放该实例，因为+ (NSMutableArray *)array函数内部调用了autorelase函数，如下为其底层实现：

// + (NSMutableArray *)array 底层函数实现
+ （NSMutableArray *）array {
         NSMutableArray *arr = [[NSMutableArray alloc] init];
         return [arr autorelease];
}

在出array函数范围之前先不释放arr对象，将其放入autoreleasePool，待到下一次清空自动释放池时对其发送一次release，剩下的就看调用者是否持有了该对象， 如果函数调用者持有了该arr对象，则arr对象继续存在，否则如果arr对象出了(NSMutableArray *)array没有在被持有，则在autoreleasePool清空的时候（之后arr引用计数为0）arr被释放内存。所以一个autorelease对象，当被__weak修饰的变量持有时，它的生命周期就是所在autoreleasePool结束前的那段时间；
b. 接下来看一下- (id)autorelease函数的底层实现:

id *objc_autorelease(id obj)
{
 return AutoreleasePoolPage::autorelease(obj);
}

AutoreleasePoolPage即自动释放池的底层实现，可以看我的博客AutoreleasePool，其实就是将需要延迟释放的对象放入了一个链表，程序中可能存在很多个自动释放池（每次会使用栈顶的自动释放池放入）。
c. 那么，实际结果真是这样的吗？？？（使用函数打印、TLS）
我们可以使用clang命令对文件进行编译，查看ARC之后的代码是怎么样的；另外通常情况需要制定引用的Framework(控制台程序通常不需要)：

xcrun -sdk iphonesimulator10.2 clang -S -fobjc-arc -emit-llvm main.m -o main.ll -F /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator.sdk/System/Library/Frameworks/UIKit.framework

使用上述命令可以生成编译器ARC之后的代码，

int main(int argc, const char * argv[]) {
    @autoreleasepool{
        NSObject *obj = [NSObject new];
    }
    return 0;
}

下面是生成的底层代码：

define i32 @main(i32, i8**) #0 {
  %3 = alloca i32, align 4 //在栈上分配变量名内存
  %4 = alloca i32, align 4
  %5 = alloca i8**, align 8
  %6 = alloca %0*, align 8 //实际上这里就是NSObject *obj变量定义处
  store i32 0, i32* %3, align 4
  store i32 %0, i32* %4, align 4
  store i8** %1, i8*** %5, align 8
  %7 = call i8* @objc_autoreleasePoolPush() #2 //创建一个自动释放池
  %8 = load %struct._class_t*, %struct._class_t** @"OBJC_CLASSLIST_REFERENCES_$_", align 8 //加载类对象地址(这里是NSObject元类) 
  %9 = load i8*, i8** @OBJC_SELECTOR_REFERENCES_, align 8, !invariant.load !8 //加载SEL地址，这里是new函数
  %10 = bitcast %struct._class_t* %8 to i8* //类型转换
  %11 = call i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8* (i8*, i8*)*)(i8* %10, i8* %9) //[NSObject new]
  %12 = bitcast i8* %11 to %0*
  store %0* %12, %0** %6, align 8 //赋值给NSObject *obj，定义在开始处
  %13 = bitcast %0** %6 to i8**
  call void @objc_storeStrong(i8** %13, i8* null) #2 //释放
  call void @objc_autoreleasePoolPop(i8* %7) //销毁自动释放池
  ret i32 0
}

第一步，在栈上先分配变量名所需要的内存（alloca x, x）；
第二步，将一个自动释放池压入栈顶（@ objc_autoreleasePoolPush()）；
第三步，中间一些代码就是获取获取NSObject元类对象以及加载new 函数的SEL地址，然后调用objc_msgSend()进行实例化；
第四步，使用完之后调用objc_storeStrong(src, value)，这个函数可以用来保存一个新对象，当然如果传入的value = null，也可以用来释放原来的对象，下面是objc_storeStrong(,)内部实现:

void objc_storeStrong(id *location, id obj)
{
    id prev = *location; //暂存现在对象
    if (obj == prev) {
        return;
    }
    objc_retain(obj); //持有新对象
    *location = obj;  //指向新对象
    objc_release(prev); //释放旧对象
}

当然，本文这里传入的是null，所以就是使用完就立即释放掉了；
而当源码中实例化对象方法改成这样时：

   NSMutableArray *obj = [NSMutableArray array];

改变实例化方式，array内部会调用autorelease：

  %7 = call i8* @objc_autoreleasePoolPush() #2
  %11 = call i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend
  %12 = call i8* @objc_retainAutoreleasedReturnValue(i8* %11) #2
...
  call void @objc_storeStrong(i8** %14, i8* null) #2
  call void @objc_autoreleasePoolPop(i8* %7)

可以看出，虽然这里看不出array里调用了autorelease（下面会验证）,但是对array返回的对象调用了objc_retainAutoreleasedReturnValue，这个其实是clang编译器对其进行了优化（只针对64位系统），会去一个叫TLS（Thread Local Storage）的地方（实际上是一个放在线程上的字典局部变量）查看该返回对象是否做了标记，这样可以节约retain和release的开销；

三、放入AutoreleasePool时机

其实上面已经说明了，通常系统提供的实例化方法如new/alloc/copy/mutablecopy等方法返回的实例对象是不会放进自动释放池，而像[NSMutableArray array]等简便函数构造器会内部调用autotorelase。
我们可以使用下面的函数和命令验证：

void _objc_autoreleasePoolPrint();

《Objective-C 高级编程》中有介绍该函数，这是一个非公开的私有函数，可以打印出自动释放池里的内容，具体的用法现在文件开头声明该外部函数

extern void _objc_autoreleasePoolPrint(void);

下面看一下[NSMutableArray new]和[NSMutableArray array]下自动释放池的情况：
[NSMutableArray new]下自动释放池情况：

objc[55819]: [0x102003000]  ................  PAGE  (hot) (cold)
objc[55819]: [0x102003038]  ################  POOL 0x102003038
objc[55819]: ##############

[NSMutableArray array]下：

objc[56005]: [0x101004000]  ................  PAGE  (hot) (cold)
objc[56005]: [0x101004038]  ################  POOL 0x101004038
objc[56005]: [0x101004040]       0x100621490  __NSArrayM
objc[56005]: ##############

可以看出，在+(NSMutableArray *)array下一个__NSArrayM被加入自动释放池，所以前面的理论是正确的。

四、应用场景

通常情况下我们不需要Autorelease也没什么关系，但是有时候理解了底层原理，我们就可以理解了一些大家常用的技巧：

for (int i=0; i<1000000; i++)
{
  @autoreleasepool{
        //实例化临时对象
    }
}

这常常用来解决内存峰值问题，但是其实如果里边不包含array这种类型的函数，即使实例化大量对象也是不会导致内存峰值出现的，如：

 for (int i=0; i<100000000; i++){
        NSMutableArray *obj = [NSMutableArray new];
        NSNumber *num = [[NSNumber alloc] initWithInt:i];
        [obj addObject:num];
        NSLog(@"%@", obj);
    }

五、小结

1. Autorelease用来延迟释放对象，该对象释放的时机在所在自动释放池情况时；
2. 使用new/alloc/copy/mutablecopy等函数实例化的对象不会放入自动释放池，相反，用其他简便构造器获（如+(NSMutableArray *)array）得到的实例则会放入自动释放池；
3. 上面讲的是通常情况便于理解，其实编译器内部还对Autorelease进行了优化，用于降低内存管理的开销。