35.iOS底层学习之内存管理自动释放池

本章提纲：
1、自动释放池的初识
2、自动释放池的数据结构
3、自动释放池的源码分析

1.自动释放池的初识

从main函数开始

main函数在iOS开发中，可以说是一个非常不显眼的存在，它隐藏在main.m文件中，是整个应用程序的入口，有着非常重要的作用。我们常见到的main函数中的内容如下：

image.png
可以看到几行简短的代码，其中@autoreleasepool就是我们今天要重点去探究的内容，来看看@autoreleasepool到底是什么。我们通过两种方式来研究下它的本质。

• Clang编译查看
  我们通过命令

xcrun -sdk iphonesimulator clang -rewrite-objc main.m                           

生成相应的.cpp文件，编译完如下：

image.png
原来的@autoreleasepool被注释掉了，随之用__AtAutoreleasePool替代了，搜索下这个关键字，发现它的定义如下：

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

这个定义其实是封装了构造函数和析构函数，举个一样的例子，我们定义一结构体Lucky如下：

struct Lucky {
    Lucky(){
        printf("22222222\n");
    }
    
    ~Lucky(){
        printf("1111111");
    }
};

来看调试过程：

image.png
image.png

当我们调用Lucky l;完毕后，打印22222222，当我们出了作用域后，调用了析构函数打印了1111111。
这样我们就能比较清楚的了解这个结构体的定义，所以关键的方法是objc_autoreleasePoolPush和objc_autoreleasePoolPop。

• 汇编开启符号断点查看
  另外一种方法，我们开启符号断点，来进行查看。
  image.png
  同样可以定位到方法objc_autoreleasePoolPush和objc_autoreleasePoolPop，我们再添加符号断点objc_autoreleasePoolPush来看下该方法所属的库。
  image.png
  最终移步到库libobjc.A.dylib，我们来进一步的研究下它的数据结构。

2.自动释放池的数据结构

我们找到方法objc_autoreleasePoolPush和objc_autoreleasePoolPop在libobjc.A.dylib中定义：

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

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


void *
_objc_autoreleasePoolPush(void)
{
    return objc_autoreleasePoolPush();
}

void
_objc_autoreleasePoolPop(void *ctxt)
{
    objc_autoreleasePoolPop(ctxt);
}

最终分别调用的是AutoreleasePoolPage::push()和AutoreleasePoolPage::pop(ctxt)。他们都是类AutoreleasePoolPage中的函数，来看下类AutoreleasePoolPage的具体定义。

2.1 AutoreleasePoolPage的结构

进一步查看AutoreleasePoolPage的定义，发现他是继承自AutoreleasePoolPageData：

class AutoreleasePoolPage;
struct AutoreleasePoolPageData
{
#if SUPPORT_AUTORELEASEPOOL_DEDUP_PTRS
    struct AutoreleasePoolEntry {
        uintptr_t ptr: 48;
        uintptr_t count: 16;

        static const uintptr_t maxCount = 65535; // 2^16 - 1
    };
    static_assert((AutoreleasePoolEntry){ .ptr = MACH_VM_MAX_ADDRESS }.ptr == MACH_VM_MAX_ADDRESS, "MACH_VM_MAX_ADDRESS doesn't fit into AutoreleasePoolEntry::ptr!");
#endif

    magic_t const magic; // 16
    __unsafe_unretained id *next; // 8
    pthread_t const thread; // 8
    //父节点
    AutoreleasePoolPage * const parent; // 8
    //子节点
    AutoreleasePoolPage *child; // 8
    
    uint32_t const depth; // 4
    uint32_t hiwat;  // 4

    AutoreleasePoolPageData(__unsafe_unretained id* _next, pthread_t _thread, AutoreleasePoolPage* _parent, uint32_t _depth, uint32_t _hiwat)
        : magic(), next(_next), thread(_thread),
          parent(_parent), child(nil),
          depth(_depth), hiwat(_hiwat)
    {
    }
};

可以了解到AutoreleasePoolPageData是一个双向链表结构，我们从对于AutoreleasePoolPage的实现的注释

/***********************************************************************
Autorelease pool implementation
A thread's autorelease pool is a stack of pointers.
Each pointer is either an object to release, or POOL_BOUNDARY which is
an autorelease pool boundary.
A pool token is a pointer to the POOL_BOUNDARY for that pool. When
the pool is popped, every object hotter than the sentinel is released.
The stack is divided into a doubly-linked list of pages. Pages are added
and deleted as necessary.
Thread-local storage points to the hot page, where newly autoreleased
objects are stored.
**********************************************************************/

大致翻译：
自动释放池的实现
一个线程的自动释放池是一堆指针。
每个指针要么是要释放的对象，要么是哨兵指针，自动释放池的边界。
一个释放池会有一个指针指向自动释放池的边界。当池子被出栈时，此时池子中的每个对象都比哨兵对象更‘热’。
这个栈被分成了双向链接的页面列表。页面在必要的时候可以被添加或者被删除。
线程本地存储指针指向新创建的存储对象的自动释放池。

AutoreleasePoolPageData中有几个成员：

• magic_t const magic：用来校验AutoreleasePoolPage结构是否完整；
• __unsafe_unretained id *next ：指向最新添加的autoreleased对象的下一个位置,初始化时指向begin；
• pthread_t const thread ：保存当前页所在的线程；
• AutoreleasePoolPage * const parent ：指向父结点，第一个AutoreleasePoolPage结点的父结点为nil;
• AutoreleasePoolPage *child ：指向子结点，最后一个AutoreleasePoolPage结点的子结点为nil;
• uint32_t const depth：当前结点的深度，从0开始，往后递增;
• uint32_t hiwat ：代表hige water mark最大入栈数量标记;

通过注释和结构我们了解到，每个page本身是一个栈结构，而page和page之间又是双向链接的，是双向链表结构，每一页的大小是4096(4k)。

3.自动释放池的源码分析

3.1自动释放池的压栈

前边分析到方法_objc_autoreleasePoolPush，它的实际实现最终找到AutoreleasePoolPage::push()，push方法的具体实现如下：

  static inline void *push() 
    {
        id *dest;
        if (slowpath(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;
    }

这里根据是否创建新页分出两个方法，需要创建新页autoreleaseNewPage(POOL_BOUNDARY)；
不需要创建，也就是当前页没满，调用autoreleaseFast(POOL_BOUNDARY)。

• 创建新页autoreleaseNewPage
  它的实现如下：

    id *autoreleaseNewPage(id obj)
    {
        AutoreleasePoolPage *page = hotPage();
        if (page) return autoreleaseFullPage(obj, page);
        else return autoreleaseNoPage(obj);
    }

创建新界面中又有两个分支：一个是autoreleaseFullPage当前页满了的情况；
另外一个是autoreleaseNoPage还没创建页的情况。

• 方法hotPage()
  image.png
  方法tls_get_direct中的具体操作对真机和模拟器进行了区分，hotPage存在了TLS中，真机的情况下通过方法_os_tsd_get_direct进行读取。

EMPTY_POOL_PLACEHOLDER是有注释的，它是一个什么样的状态下会返回nil呢？注释是这样解释的：

// 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.
# define EMPTY_POOL_PLACEHOLDER ((id*)1)

EMPTY_POOL_PLACEHOLDER是一个宏定义，它的注释是：
EMPTY_POOL_PLACEHOLDER是存储在TLS中当恰巧一个池子被入栈或者出栈，并且这个池子不含有对象。这样做会节省内存，当栈顶对象压入或者弹出池子，但是从来也没有被使用过。

• 方法autoreleaseFullPage
  image.png
• 方法autoreleaseNoPage
  image.png
  以上两个方法都包含了方法添加对象到当前页中add方法，来看下它的具体实现：
  image.png
  add方法首先确保非满状态，然后把obj添加到next的位置。
  以上走的是创建新页autoreleaseNewPage的流程，接下来看autoreleaseFast的流程：

   static inline id *autoreleaseFast(id obj)
    {
        AutoreleasePoolPage *page = hotPage();
        //page没满 直接调用add 把obj添加到next指向的位置
        if (page && !page->full()) {
            return page->add(obj);
        } else if (page) {
            //page存在 但是已经满了 开辟新页 并把对象存到新的page中
            return autoreleaseFullPage(obj, page);
        } else {
            //还没创建过新页 创建新页 并把对象obj存进去
            return autoreleaseNoPage(obj);
        }
    }

以上就是obj入栈的过程，主要通过三个函数去处理autoreleaseFullPage和autoreleaseNoPage还有add。分别对应对象插入到新的位置时的三种情况：
1、如果有正好的位置next，那么直接把对象objadd进去；
2、如果当前页已经满了，那么去走autoreleaseFullPage，也就是开辟新页，把新页和前一页进行关联，把next位置更新一下，把对象存的新开辟的新页中；
3、如果当前还没创建页，那么就创建一个首页，并把要存的对象存进去；

3.2自动释放池的出栈

出栈的关键方法是：objc_autoreleasePoolPop，最终找到的方法是AutoreleasePoolPage::pop(ctxt)，pop的源码如下：

  static inline void
    pop(void *token)
    {
        AutoreleasePoolPage *page;
        id *stop;
        //栈顶的pool未被使用
        if (token == (void*)EMPTY_POOL_PLACEHOLDER) {
            // Popping the top-level placeholder pool.
            //弹出栈顶指针
            page = hotPage();
            if (!page) {
                //这个pool没有被使用过 清空
                // Pool was never used. Clear the placeholder.
                return setHotPage(nil);
            }
            //如果Pool已经被使用，那么正常弹出它的内容
            // Pool was used. Pop its contents normally.
            //保留pool pages为了再使用
            // Pool pages remain allocated for re-use as usual.
            //拿到hotPage然后往前遍历 拿到最前边的父节点
            page = coldPage();
            token = page->begin();
        } else {
            //通过地址找到对应的页 p/size 每页4k 2的12次方 2的十次方乘以4 4k
            page = pageForPointer(token);
        }

        stop = (id *)token;
        //不是边界
        if (*stop != POOL_BOUNDARY) {
            if (stop == page->begin()  &&  !page->parent) {
                // 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
                //存在自动释放池的第一个节点存储的第一个对象不是边界符的情况, 有两种情况导致:
                //1.顶层池没释放, 但留下了第一个节点
                //2.没有自动释放池的 autorelease 对象
                
            } else {
                // Error. For bincompat purposes this is not 
                // fatal in executables built with old SDKs.
                //报错
                return badPop(token);
            }
        }

        if (slowpath(PrintPoolHiwat || DebugPoolAllocation || DebugMissingPools)) {
            return popPageDebug(token, page, stop);
        }

        return popPage<false>(token, page, stop);
    }

此方法中真正释放对象的方法是popPage。

 popPage(void *token, AutoreleasePoolPage *page, id *stop)
    {
        if (allowDebug && PrintPoolHiwat) printHiwat();

        //遍历当前页 直到为stop的位置 跳出遍历
        page->releaseUntil(stop);

        // memory: delete empty children
        if (allowDebug && DebugPoolAllocation  &&  page->empty()) {
            // special case: delete everything during page-per-pool debugging
            //删除空页 kill内部是do-while循环 向父节点的方向遍历并把前一个节点置空
            AutoreleasePoolPage *parent = page->parent;
            page->kill();
            setHotPage(parent);
            //当前page为空 但是前一页不为空 那么全部删除
        } else if (allowDebug && DebugMissingPools  &&  page->empty()  &&  !page->parent) {
            // special case: delete everything for pop(top)
            // when debugging missing autorelease pools
            page->kill();
            setHotPage(nil);
            //page有子节点
        } else if (page->child) {
            //有一半是空的 子节点存在 那么从子节点开始删除
            // hysteresis: keep one empty child if page is more than half full
            if (page->lessThanHalfFull()) {
                page->child->kill();
            }
            //否则去查下子节点的子节点 开始清空
            else if (page->child->child) {
                page->child->child->kill();
            }
        }
    }

其中kill方法主要是一个do-while循环，从后往前遍历父节点，父节点存在把后一节点删除，这样一个一个移除。

而方法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) {// 一直循环到 next 指针指向 stop 为止
            // Restart from hotPage() every time, in case -release 
            // autoreleased more objects
            AutoreleasePoolPage *page = hotPage();

            // fixme I think this `while` can be `if`, but I can't prove it
            while (page->empty()) { //向前查找 找到第一个不为空的page
                page = page->parent;
                setHotPage(page);
            }

            page->unprotect();

            id obj = *--page->next; // 先将 next 指针向前移位, 然后再取出移位后地址中的值
            memset((void*)page->next, SCRIBBLE, sizeof(*page->next));
            page->protect();

            if (obj != POOL_BOUNDARY) {

                objc_release(obj);//进行一次release释放
            }
        }

对拿到的stop的节点之前进行遍历，并释放对象。

实例扩展

之前在项目中使用过自动释放池降低内存峰值。如果在短时间内创建大量的临时变量，那么会导致内存峰值增大，使用自动释放池可以有效的降低峰值。原因是自己创建个池子大量的临时变量就在自己的池子里了，而不是线程的主池里。