AutoreleasePool.jpeg

• Autorelease Pool：是iOS内存管理机制中很重要的一个部分。 Autorelease Pool字面上看起来是「自动释放池」的意思，在这个池子里去管理对象的内存。

简介：

Autorelease Pool的是在需要延迟释放某些对象的情况时，可以把他们先放到对应的Autorelease Pool中，等Autorelease Pool生命周期结束时再一起释放。这些对象会被发送autorelease消息。在非ARC时代，我们显示地发送autorelease消息，在ARC时代，系统会帮我们做这些事情

形式：

• 在没有手加Autorelease Pool的情况下，Autorelease对象是在当前的runloop迭代结束时释放的，而它能够释放的原因是系统在每个runloop迭代中都加入了自动释放池Push和Pop。
• 在嵌套的autoreleasePool中，只有最里层的pool使对象的引用计数加1,反过来说就是最里层的pool会阻止外层的pool对对象的引用，等最里层的autoreleasePool执行完之后再进行释放的。

@autoreleasepool {
    // Code that creates autoreleased objects.
}

@autoreleasepool {
    // code
    @autoreleasepool {
       // code
    }
    . . .
}

场景

Cocoa中总是会期望代码在一个Autorelease Pool Block中运行，否则那些被autorelease的对象就不能被释放了，这就内存泄露了。在AppKit和UIKit框架中，当处理一个事件循环的一次迭代的时候（比如一次鼠标点击事件或一次tap事件），会自动在一个autorelease pool block里完成，因此通常你不需要自己去创建一个autorelease pool block，甚至你都很少看到这种代码。

1. 你需要写一个循环，里面会创建很多临时的对象。
   这时候你可以在循环内部的代码块里使用一个autorelease pool block，这样这些对象就能在一次迭代完成后被释放掉。这种方式可以降低内存最大占用。
2. 当你大量使用辅助线程你需要在线程的任务代码中创建自己的autorelease pool block。

NSArray *urls = <# An array of file URLs #>;
for (NSURL *url in urls) {
 
    @autoreleasepool {
        NSError *error;
        NSString *fileContents = [NSString stringWithContentsOfURL:url
                                         encoding:NSUTF8StringEncoding error:&error];
        /* Process the string, creating and autoreleasing more objects. */
    }
}

底层原理

AutoreleasePool创建和释放

• App启动后，苹果在主线程 RunLoop 里注册了两个 Observer，其回调都是 _wrapRunLoopWithAutoreleasePoolHandler()。
• 第一个 Observer 监视的事件是 Entry(即将进入Loop)，其回调内会调用 _objc_autoreleasePoolPush() 创建自动释放池。其 order 是-2147483647，优先级最高，保证创建释放池发生在其他所有回调之前。
• 第二个 Observer 监视了两个事件： BeforeWaiting(准备进入休眠) 时调用_objc_autoreleasePoolPop() 和 _objc_autoreleasePoolPush() 释放旧的池并创建新池；Exit(即将退出Loop) 时调用 _objc_autoreleasePoolPop() 来释放自动释放池。这个 Observer 的 order 是 2147483647，优先级最低，保证其释放池子发生在其他所有回调之后。
• 在主线程执行的代码，通常是写在诸如事件回调、Timer回调内的。这些回调会被 RunLoop 创建好的 AutoreleasePool 环绕着，所以不会出现内存泄漏，开发者也不必显示创建 Pool 了。
  总结：
  也就是说AutoreleasePool创建是在一个RunLoop事件开始之前(push)，AutoreleasePool释放是在一个RunLoop事件即将结束之前(pop)。
  AutoreleasePool里的Autorelease对象的加入是在RunLoop事件中，AutoreleasePool里的Autorelease对象的释放是在AutoreleasePool释放时。

AutoreleasePool实现原理

在终端中使用clang -rewrite-objc命令将下面的OC代码重写成C++的实现：

#import <Foundation/Foundation.h>

int main(int argc, const char * argv[]) {
    
    @autoreleasepool {
        NSLog(@"Hello, World!");
    }
 
    return 0;
}

在cpp文件代码中我们找到main函数代码如下：

int main(int argc, const char * argv[]) {

    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 
        NSLog((NSString *)&__NSConstantStringImpl__var_folders_kb_06b822gn59df4d1zt99361xw0000gn_T_main_d39a79_mi_0);
    }

    return 0;
}

可以看到苹果通过声明一个__AtAutoreleasePool类型的局部变量__autoreleasepool实现了@autoreleasepool{}。
__AtAutoreleasePool的定义如下:

extern "C" __declspec(dllimport) void * objc_autoreleasePoolPush(void);
extern "C" __declspec(dllimport) void objc_autoreleasePoolPop(void *);

struct __AtAutoreleasePool {
  __AtAutoreleasePool() {atautoreleasepoolobj = objc_autoreleasePoolPush();}
  ~__AtAutoreleasePool() {objc_autoreleasePoolPop(atautoreleasepoolobj);}
  void * atautoreleasepoolobj;
};

根据构造函数和析构函数的特点（自动局部变量的构造函数是在程序执行到声明这个对象的位置时调用的，而对应的析构函数是在程序执行到离开这个对象的作用域时调用），我们可以将上面两段代码简化成如下形式：

int main(int argc, const char * argv[]) {

    /* @autoreleasepool */ {
        void *atautoreleasepoolobj = objc_autoreleasePoolPush();
        NSLog((NSString *)&__NSConstantStringImpl__var_folders_kb_06b822gn59df4d1zt99361xw0000gn_T_main_d39a79_mi_0);
        objc_autoreleasePoolPop(atautoreleasepoolobj);
    }

    return 0;
}

至此，我们可以分析出，单个自动释放池的执行过程就是objc_autoreleasePoolPush() —> [object autorelease] —> objc_autoreleasePoolPop(void *)。

来看一下objc_autoreleasePoolPush 和 objc_autoreleasePoolPop 的实现：

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

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

AutoreleasePoolPage实现和介绍

AutoreleasePoolPage 是一个 C++ 中的类，它在 NSObject.mm 中的定义是这样的：

class AutoreleasePoolPage {
#   define EMPTY_POOL_PLACEHOLDER ((id*)1)

#   define POOL_BOUNDARY nil
    static pthread_key_t const key = AUTORELEASE_POOL_KEY;
    static uint8_t const SCRIBBLE = 0xA3;  // 0xA3A3A3A3 after releasing
    static size_t const SIZE = 
#if PROTECT_AUTORELEASEPOOL
        PAGE_MAX_SIZE;  // must be multiple of vm page size
#else
        PAGE_MAX_SIZE;  // size and alignment, power of 2
#endif
    static size_t const COUNT = SIZE / sizeof(id);

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

• magic 检查校验完整性的变量
• next 指向新加入的autorelease对象
• thread page当前所在的线程，AutoreleasePool是按线程一一对应的（结构中的thread指针指向当前线程）
• parent 父节点 指向前一个page
• child 子节点 指向下一个page
• depth 链表的深度，节点个数
• hiwat high water mark 数据容纳的一个上限
• EMPTY_POOL_PLACEHOLDER 空池占位
• POOL_BOUNDARY 是一个边界对象 nil,之前的源代码变量名是 POOL_SENTINEL哨兵对象,用来区别每个page即每个 AutoreleasePoolPage 边界
• PAGE_MAX_SIZE = 4096, 为什么是4096呢？其实就是虚拟内存每个扇区4096个字节,4K对齐的说法。
• COUNT 一个page里对象数

双向链表

AutoreleasePool并没有单独的结构，而是由若干个AutoreleasePoolPage以双向链表的形式组合而成的栈结构（分别对应结构中的parent指针和child指针）

双向链表.png

parent和child就是用来构造双向链表的指针。parent指向前一个page, child指向下一个page。
一个AutoreleasePoolPage的空间被占满时，会新建一个AutoreleasePoolPage对象，连接链表，后来的autorelease对象在新的page加入。

AutoreleasePoolPage.png

AutoreleasePool的本质

关于AutoreleasePool的底层实现NSObject.mm里，源码地址：https://opensource.apple.com/source/objc4/objc4-532/runtime/NSObject.mm.auto.html
objc_autoreleasePoolPush()和objc_autoreleasePoolPop(__autoreleasepool)的实现如下：

void* objc_autoreleasePoolPush(void)
{
    if (UseGC) return NULL; //如果使用垃圾回收机制
    return AutoreleasePoolPage::push();
}

void objc_autoreleasePoolPop(void *ctxt)
{
    if (UseGC) return;

    // fixme rdar://9167170
    if (!ctxt) return;

    AutoreleasePoolPage::pop(ctxt);
}

从上面可以发现，C++类AutoreleasePoolPage才是实际的实现所在，找到AutoreleasePoolPage：

class AutoreleasePoolPage 
{
#define POOL_SENTINEL 0
    static size_t const SIZE = 
#if PROTECT_AUTORELEASEPOOL
        4096;  // must be multiple of vm page size
#else
        4096;  // size and alignment, power of 2
#endif
    magic_t const magic; //用于数据校验
    id *next;            //栈顶地址
    pthread_t const thread; //所在的线程
    AutoreleasePoolPage * const parent; //父对象
    AutoreleasePoolPage *child; //子对象
    uint32_t const depth;   //page的序号？
    uint32_t hiwat;
    ...
}

去除了一些不重要的代码，可以看出这是一个典型的双向列表结构，每个Page大小为4096 Byte，所以AutoreleasePool实质上是一个双向AutoreleasePoolPage列表；接下来分析一下自动释放池的工作过程：

创建自动释放池

void* objc_autoreleasePoolPush()内部实际调用的是AutoreleasePoolPage::push()函数，其实现如下：

static inline void *push() 
    {
        if (!hotPage()) {
            setHotPage(new AutoreleasePoolPage(NULL));
        } 
        id *dest = autoreleaseFast(POOL_SENTINEL);
        assert(*dest == POOL_SENTINEL);
        return dest;
    }

hotPage()是找出当前的正在使用的page，第一次调用时hotPage为NULL，所以新建一个parent=NULL的AutoreleasePoolPage对象作为自动释放池加入栈中，并将其设置为hotPage，然后返回POOL_SENTINEL的地址赋值给main（）函数里的变量 __autoreleasepool；

然后将一个哨兵对象POOL_SENTINEL压入栈顶，即调用autoreleaseFast（POOL_SENTINEL）

static inline id *autoreleaseFast(id obj)
    {
        AutoreleasePoolPage *page = hotPage();
        if (page && !page->full()) {
            return page->add(obj);
        } else {
            return autoreleaseSlow(obj);
        }
    }

添加对象进自动释放池

可以看出，如果当前有page并且没有满，则直接将对象入栈顶（page->add(obj)）:

id *add(id obj)
    {
        assert(!full());
        unprotect();
        *next++ = obj;
        protect();
        return next-1;
    }

将对象压入栈顶，然后将栈顶指针下移；
如果上述autoreleaseFast(id obj)中的page已经满了，则执行autoreleaseSlow(obj)

id *autoreleaseSlow(id obj)
    {
        AutoreleasePoolPage *page;
        page = hotPage();
        //如果没有page，则新建一个自动释放池，并添加obj对象进释放池
        if (!page) {
            objc_autoreleaseNoPool(obj);
            return NULL;
        }
        //如果当前hotPage已经满了，则以链表的形式新增一个page并添加到当前page的后面，然后将此设置为hotPage；
        do {
            if (page->child) page = page->child;
            else page = new AutoreleasePoolPage(page);
        } while (page->full());

        setHotPage(page);
        return page->add(obj);
    }

基本逻辑即，如果page不存在则，创建新的自动释放池(PoolPage),并将对象加进池子；如果已经存在自动释放池在栈中，且hotPage满了，则遍历其子page，如果存在没满（page->full()==NO）的子page,则将该子page设置为hotPage，否则如果都满了,则以最后一个子page为父page，新建一个page,插入当前的page链表,同样设置该新建的page为hotPage，然后将自动释放对象加入page；

销毁自动释放池

销毁自动释放池的调用方式是：

void AutoreleasePoolPage::pop(void *token)

token 即push()的返回值，实际上就是POOL_SENTINEL的地址(__autoreleasepool)通过该地址即可找到所在Page的地址指针

static inline void pop(void *token) 
    {
        AutoreleasePoolPage *page;
        id *stop;

        if (token) {
            page = pageForPointer(token); //找到所在的page地址
            stop = (id *)token; //POOL_SENTINEL的地址，从栈顶释放对象直到这个位置
        } else {
            // Token 0 is top-level pool
            page = coldPage();
            stop = page->begin();
        }

        page->releaseUntil(stop); //对自动释放池中对象调用objc_release()进行释放

        // memory: delete empty children
        // hysteresis: keep one empty child if this page is more than half full
        // special case: delete everything for pop(0)
        if (!token) {
            page->kill();
            setHotPage(NULL);
        } else if (page->child) {
            if (page->lessThanHalfFull()) {
                page->child->kill();
            }
            else if (page->child->child) {
                page->child->child->kill();
            }
        }
    }

该过程主要分为两步：

一、page->releaseUntil(stop)，对栈顶（page->next）到stop地址（POOL_SENTINEL）之间的所有对象调用objc_release()，进行引用计数减1；

二、清空page对象page->kill()，有两句注释

// hysteresis: keep one empty child if this page is more than half full
// special case: delete everything for pop(0)

除非是pop(0)方式调用，这样会清理掉所有page对象；否则，在当前page存放的对象大于一半时，会保留一个空的子page，这样估计是为了可能马上需要新建page节省创建page的开销吧.

对应代码

if (page->child) {
           if (page->lessThanHalfFull()) {
               page->child->kill(); //全部删除
           }
           else if (page->child->child) {
               page->child->child->kill();//保留一个子page
           }
       }