AutoreleasePool是OC中的一种自动回收机制，在ARC的模式下已经很少能看到autorelease了，它可以延迟变量release的时机。在OC的main.m中就有一个autoreleasepool，本篇结合runtime研究一下autoreleasepool的底层是如何实现的。

问答模式

问：什么时候需要使用自动释放池？

官方解释：基本分为如下三点
1、当我们需要创建大量的临时变量的时候，可以通过@autoreleasepool 来减少内存峰值。
2、创建了新的线程执行Cocoa调用。
3、如果您的应用程序或线程是长期存在的，并且可能会生成大量自动释放的对象，那么您应该定期清空并创建自动释放池（就像UIKit在主线程上所做的那样）；否则，自动释放的对象会累积，内存占用也会增加。但是，如果创建的线程不进行Cocoa调用，则不需要创建自动释放池。

问：为什么会减少内存峰值？
答：借用YYImage的代码打个比方。
比如业务需要在一个代码块中需要创建大量临时变量，或临时变量足够大，占用了很多内存，可以在临时变量使用完以后就立即释放掉，在ARC的环境下只能通过自动释放池实现。

if ([UIDevice currentDevice].isSimulator) {
        @autoreleasepool {
            NSString *outPath = [NSString stringWithFormat:@"%@ermilio.gif.png",IMAGE_OUTPUT_DIR];
            NSData *outData = UIImagePNGRepresentation([UIImage imageWithData:gif]);
            [outData writeToFile:outPath atomically:YES];
            [gif writeToFile:[NSString stringWithFormat:@"%@ermilio.gif",IMAGE_OUTPUT_DIR] atomically:YES];
        }
        @autoreleasepool {
            NSString *outPath = [NSString stringWithFormat:@"%@ermilio.apng.png",IMAGE_OUTPUT_DIR];
            NSData *outData = UIImagePNGRepresentation([UIImage imageWithData:apng]);
            [outData writeToFile:outPath atomically:YES];
            [apng writeToFile:[NSString stringWithFormat:@"%@ermilio.png",IMAGE_OUTPUT_DIR] atomically:YES];
        }
        @autoreleasepool {
            NSString *outPath = [NSString stringWithFormat:@"%@ermilio_q85.webp.png",IMAGE_OUTPUT_DIR];
            NSData *outData = UIImagePNGRepresentation([YYImageDecoder decodeImage:webp_q85 scale:1]);
            [outData writeToFile:outPath atomically:YES];
            [webp_q85 writeToFile:[NSString stringWithFormat:@"%@ermilio_q85.webp",IMAGE_OUTPUT_DIR] atomically:YES];
        }
}

再比如在循环的场景下，如果创建大量的临时变量，会使内存峰值持续增加，加入自动释放池以后，在每次循环结束时，超出自动释放池的作用域，使得内部的大量临时变量被释放，从而大大降低了内存的使用。

for (int i = 0; i < count; i++) {
        @autoreleasepool {
            id imageSrc = _images[i];
            NSDictionary *frameProperty = NULL;
            if (_type == YYImageTypeGIF && count > 1) {
                frameProperty = @{(NSString *)kCGImagePropertyGIFDictionary : @{(NSString *) kCGImagePropertyGIFDelayTime:_durations[i]}};
            } else {
                frameProperty = @{(id)kCGImageDestinationLossyCompressionQuality : @(_quality)};
            }
}

上述这几种情况如果没必要就别这么写，毕竟创建自动释放池也需要耗费内存。

自动释放池的实现原理

在开始之前先看一下自动释放池的大致结构图

自动释放池结构图.png

上图就是自动释放池的结构图，可能现在看不懂，这里先有个概况继续往下看就明白了，不太会画图，反正意思表达出来了。

查看main.cpp

我们先在终端clang一下main.m，变成C++实现
clang -rewrite-objc main.m -o main.cpp
我们会得到一个main.cpp文件，打开这个文件翻到最底部会看到这个代码

int main(int argc, const char * argv[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 

        NSLog((NSString *)&__NSConstantStringImpl__var_folders_vg_bngxds5x5q90wwst5gl1jq140000gn_T_main_1b100d_mi_0);
    }
    return 0;
}

发现原来autoreleasepool也是一个对象，我们在这个cpp文件中查找__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;
};

结构体只提供了一个构造函数和一个析构函数，里面分别调用了objc_autoreleasePoolPush和objc_autoreleasePoolPop，这个objc前缀告诉我们，是不是能到runtime里面搜索一下，在rumtime源码中全局搜索objc_autoreleasePoolPush，找到这个函数

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

我们发现了正主，是一个类AutoreleasePoolPage

AutoreleasePoolPage

class AutoreleasePoolPage 
{
   ···
   //当自动释放池为空时的一个占位符
#   define EMPTY_POOL_PLACEHOLDER ((id*)1)
    //边界符，用来区别每个AutoreleasePoolPage的边界
#   define POOL_BOUNDARY nil
    //线程的key，通过key值寻找线程下的AutoreleasePoolPage
    static pthread_key_t const key = AUTORELEASE_POOL_KEY;
    //4096个字节，表示每个page的大小，因为虚拟内存每个扇区4096个字节
    PAGE_MAX_SIZE;  
    //一个page里面的对象数量
    static size_t const COUNT = SIZE / sizeof(id);
    //共需要占用56个字节
    magic_t const magic;                   // 16字节，校验完整性的变量
    id *next;                              // 8字节，指向下一个对象的指针
    pthread_t const thread;                // 8字节，所属线程，page和thread是一一对应关系
    AutoreleasePoolPage * const parent;    // 8字节，父节点，指向上一个page
    AutoreleasePoolPage *child;            // 8字节，子节点，指向下一个page
    uint32_t const depth;                  // 4字节，表示链表一共有多少个节点
    uint32_t hiwat;                        // 4字节，high water marks表示自动释放池中最多能存放的对象个数
    ···
}

从这个类中我们得到了以下内容

• EMPTY_POOL_PLACEHOLDER：
  当自动释放池为空时的一个占位符，就是在第一次push时，先用这个字段把AutoreleasePoolPage的位置占上。

// EMPTY_POOL_PLACEHOLDER is stored in TLS when exactly one pool is 
// pushed and it has never contained any objects. This saves memory 
// when the top level (i.e. libdispatch) pushes and pops pools but 
// never uses them.

• POOL_BOUNDARY ：
  边界符，用来区别每个AutoreleasePoolPage的边界，我们从创建page的时候可以得知

// We are pushing an object or a non-placeholder'd pool.
// Install the first page.
   AutoreleasePoolPage *page = new AutoreleasePoolPage(nil);
   setHotPage(page);//设置活跃页
// Push a boundary on behalf of the previously-placeholder'd pool.
   if (pushExtraBoundary) {
       page->add(POOL_BOUNDARY);
   }

• key：
  线程的key，通过key值寻找线程下的AutoreleasePoolPage
• PAGE_MAX_SIZE：
  4096个字节，表示每个page的大小，因为虚拟内存每个扇区4096个字节
• COUNT：
  一个page里面的对象数量
• magic：
  校验完整性的变量，占用16字节
• next：
  指向下一个对象的指针，占用8字节
• thread：
  所属线程，page和thread是一一对应关系，占用8字节
• parent：
  父节点，指向上一个page，占用8字节，看到这里我们发现这个自动释放池其实是个双向链表，不过是以栈的形式存取的
• child：
  子节点，指向下一个page，占用8字节
• depth：
  表示链表一共有多少个节点，占用4字节
• hiwat：
  high water marks表示自动释放池中最多能存放的对象个数，占用4字节

从上面的分析我们可以得知，page本身占用了56个字节，而一个AutoreleasePoolPage一共4096个字节，也就是说我们还剩下4040个字节可以用来放对象。接下来看看它的push和pop的过程。

1、Push

static inline void *push() 
    {
        id *dest;
        if (DebugPoolAllocation) {
            // Each autorelease pool starts on a new pool page.
            dest = autoreleaseNewPage(POOL_BOUNDARY);
        } else {
            dest = autoreleaseFast(POOL_BOUNDARY);
        }
        assert(dest == EMPTY_POOL_PLACEHOLDER || *dest == POOL_BOUNDARY);
        return dest;
    }

这里我们不看Debug，直接找autoreleaseFast函数

static inline id *autoreleaseFast(id obj)
    {
        //获取当前活跃的page
        AutoreleasePoolPage *page = hotPage();
        if (page && !page->full()) {
            return page->add(obj);
        } else if (page) {
            return autoreleaseFullPage(obj, page);
        } else {
            return autoreleaseNoPage(obj);
        }
    }

从代码中我们得知，先调用hotPage()函数获取page，当page不满时，我们调用add()函数；当对象满了时，调用了autoreleaseFullPage()函数；当没获取到page时，调用autoreleaseNoPage()函数。接下来我们看看这几个函数都做了什么

1.1、hotPage()

static inline AutoreleasePoolPage *hotPage() 
    {
        //从一个键值对中获取当前page
        AutoreleasePoolPage *result = (AutoreleasePoolPage *)
            tls_get_direct(key);
        if ((id *)result == EMPTY_POOL_PLACEHOLDER) return nil;
        if (result) result->fastcheck();
        return result;
    }

从代码中我们得知hotPage函数是从一个键值对中获取当前活跃的page，而这个key就是上面我们看到的

static pthread_key_t const key = AUTORELEASE_POOL_KEY;

1.2、page->add(obj)

id *add(id obj)
    {
        assert(!full());
        unprotect();
        id *ret = next;  // faster than `return next-1` because of aliasing
        *next++ = obj;
        protect();
        return ret;
    }

从源码中我们得知，add()是向链表中增加一个对象，简单的改变了指针的指向，这不必细说。

1.3、autoreleaseFullPage(obj, page)

id *autoreleaseFullPage(id obj, AutoreleasePoolPage *page)
    {
        // The hot page is full. 
        // Step to the next non-full page, adding a new page if necessary.
        // Then add the object to that page.
        assert(page == hotPage());
        assert(page->full()  ||  DebugPoolAllocation);

        do {
            if (page->child) page = page->child;
            else page = new AutoreleasePoolPage(page);
        } while (page->full());

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

从源码中我们得知，这个page满了以后，循环遍历自动释放池中的page，直到找到一个page不满时，我们把对象添加进去。

1.4、autoreleaseNoPage(obj)

id *autoreleaseNoPage(id obj)
    {
        bool pushExtraBoundary = false;
        //判断是否有空池占位符
        if (haveEmptyPoolPlaceholder()) {
            pushExtraBoundary = true;
        } else if (obj != POOL_BOUNDARY  &&  DebugMissingPools) {
            //没有可用pool
            objc_autoreleaseNoPool(obj);
            return nil;
        }
        else if (obj == POOL_BOUNDARY  &&  !DebugPoolAllocation) {
            //当前page还没有空池占位符，先加上占位符
            return setEmptyPoolPlaceholder();
        }
       //如果执行到这里，表示目前没有可有page，要新建一个
        AutoreleasePoolPage *page = new AutoreleasePoolPage(nil);
        setHotPage(page);//设置激活页
        
        // Push a boundary on behalf of the previously-placeholder'd pool.
        if (pushExtraBoundary) {
            //如果有占位符，则这里加上边界符
            page->add(POOL_BOUNDARY);
        }
         //把autorelease对象添加进来
        return page->add(obj);
    }

1.5、Push总结

AutoreleasePoolPage-push.png

流程基本如上图所示

2、Pop

在Pop时，会传入当前的token，token就是

static inline void pop(void *token) 
    {
        //token就是边界符
        if (token == (void*)EMPTY_POOL_PLACEHOLDER) {
            if (hotPage()) {
                pop(coldPage()->begin());
            } else {
                setHotPage(nil);
            }
            return;
        }
        //找到最上边的page，即当前的page
        page = pageForPointer(token);
        stop = (id *)token;
        if (*stop != POOL_BOUNDARY) {
            if (stop == page->begin()  &&  !page->parent) {
                //讲道理，如果token不等于POOL_BOUNDARY，pageForPointer()计算过后，理论上是一定会进入这里的
            } else {
                //走这就出问题了
                // Error. For bincompat purposes this is not 
                // fatal in executables built with old SDKs.
                return badPop(token);
            }
        }
        
        //更新当前自动释放池最大存储数
        if (PrintPoolHiwat) printHiwat();
        //清空token之前的autorelease对象
        page->releaseUntil(stop);
        //清空操作
        if (page->lessThanHalfFull()) {
            page->child->kill();
        } else if (page->child->child) {
            page->child->child->kill();
       } 
    }

从源码中我们看到了Pop的过程分成了三步，
1、判断token是否等于EMPTY_POOL_PLACEHOLDER
首先我们要知道token实际上是个边界符，通常情况下等于POOL_BOUNDARY，其次我们要记得上面说过自动释放池其实是个双向链表，不过是以栈的形式存取的，所以当执行这个判断条件时，实际上就是Pop到了最后一步了。
2、当token不等于POOL_BOUNDARY时
这一步一般是不会进来的，只有在没有自动释放池且调用了autorelease时才会出现。但生活还是要继续的...
在做接下来的操作前，先获取最新的page，即当前page

page = pageForPointer(token);
static AutoreleasePoolPage *pageForPointer(uintptr_t p) 
    {
        AutoreleasePoolPage *result;
        uintptr_t offset = p % SIZE;//size就是4096，每个page最大size

        result = (AutoreleasePoolPage *)(p - offset);
        result->fastcheck();

        return result;
    }

下面这个操作知识为了确保这个token拿到的page没问题。

stop = (id *)token;
        if (*stop != POOL_BOUNDARY) {
            if (stop == page->begin()  &&  !page->parent) {
                //讲道理，如果token不等于POOL_BOUNDARY，pageForPointer()计算过后，理论上是一定会进入这里的
                // Start of coldest page may correctly not be POOL_BOUNDARY:
                // 1. top-level pool is popped, leaving the cold page in place
                // 2. an object is autoreleased with no pool
            } else {
                //走这就出问题了
                // Error. For bincompat purposes this is not 
                // fatal in executables built with old SDKs.
                return badPop(token);
            }
        }

3、最后一步释放page里面的对象。
在释放操作之前，更新当前自动释放池最大存储数。

if (PrintPoolHiwat) printHiwat();

static void printHiwat()
    {
        AutoreleasePoolPage *p = hotPage();
        uint32_t mark = p->depth*COUNT + (uint32_t)(p->next - p->begin());
        if (mark > p->hiwat  &&  mark > 256) {
            for( ; p; p = p->parent) {
                p->unprotect();
                p->hiwat = mark;
                p->protect();
            }

这一步操作释放token之前的autorelease对象。

//释放token之前的autorelease对象
page->releaseUntil(stop);

void releaseUntil(id *stop) 
    {
        // Not recursive: we don't want to blow out the stack 
        // if a thread accumulates a stupendous amount of garbage
        
        while (this->next != stop) {
            while (page->empty()) {
                page = page->parent;
                setHotPage(page);
            }

            page->unprotect();
            id obj = *--page->next;
            memset((void*)page->next, SCRIBBLE, sizeof(*page->next));
            page->protect();

            if (obj != POOL_BOUNDARY) {
                objc_release(obj);
            }
        }

kill操作，如果当前page小于当前page的一半时，则把当前页的所有子节点都kill掉，否则从子节点的子节点开始kill。

//清空操作
        if (page->lessThanHalfFull()) {
            page->child->kill();
        } else if (page->child->child) {
            page->child->child->kill();
       } 

到目前为止，我们明白了autorelease对象的释放是在autoreleasePool释放之前。

参考资料

autorelease和autoreleasePoolPage--你真的了解么?
OC源码 —— autoreleasepool
官方runtime源码