iOS底层探索-自动释放池-六虎

1、概述

OC 中的一种内存主动收回机制，它能够将参加AutoreleasePool中的变量release的时机推迟
当创立一个目标，在正常情况下，变量会在超出其效果域时当即 release ，假如将其参加到主动开释池中，这个目标并不会当即开释，而会等到 runloop 休眠 / 超出autoreleasepool效果域之后进行开释
从程序发动到加载完结，主线程对应的 Runloop 会处于休眠状况，等待用户交互来唤醒 Runloop
用户每次交互都会发动一次 Runloop ，用于处理用户的一切点击、触摸等事情
Runloop 在监听到交互事情后，就会创立主动开释池，并将一切推迟开释的目标增加到主动开释池中
在一次完好的 Runloop 结束之前，会向主动开释池中一切目标发送 release 音讯，然后毁掉主动开释池

2、底层探索

预备简略代码

#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        NSLog(@"Hello, World!");
    }
    return 0;
}

转换成.cpp文件：

clang -rewrite-objc main.m -o main.cpp

int main(int argc, const char * argv[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 
        NSLog((NSString *)&__NSConstantStringImpl__var_folders_jl_d06jlfkj2ws74_5g45kms07m0000gn_T_main_da0d58_mi_0);
    }
    return 0;
}

autoreleasepool 变成了__AtAutoreleasePool类型声明的代码

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

前边了解过这种写法是在结构体结构时调用objc_autoreleasePoolPush函数，在 结构体退出效果域析构 时调用objc_autoreleasePoolPop函数，这两个函数也是下边研讨的重点（在 main 函数中 autoreleasepool 处设置断点检查汇编也能够看到这两个函数的符号调用）

2.1、打印主动开释池结构

测试项目，封闭ARC形式

手动增加一个目标到主动开释池，并打印主动开释池结构

// 导入 _objc_autoreleasePoolPrint 函数,用于打印主动开释池的结构
extern void _objc_autoreleasePoolPrint(void);
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        NSObject *objc = [[[NSObject alloc] init] autorelease];
        _objc_autoreleasePoolPrint();
    }
    return 0;
}

_objc_autoreleasePoolPrint调用 AutoreleasePoolPage::printAll()（经过AutoreleasePoolPage 的命名空间调用printAll()）；按照主动开释池的结构，经过双向链表遍历page，依次读取 page 中的内容并进行打印

##############
AUTORELEASE POOLS for thread 0x1000ebe00
2 releases pending.
[0x10700b000]  ................  PAGE  (hot) (cold)
[0x10700b038]  ################  POOL 0x10700b038
[0x10700b040]       0x100705f60  NSObject
##############

打印了当时主动开释池所属线程，与 2 个需求开释的目标：岗兵目标：POOL 和 手动参加主动开释池 的目标objc
当时的Page信息，占56字节，由于只要一页，便是冷页面，也是热页面

2.2、objc_autoreleasePoolPush

void *
objc_autoreleasePoolPush(void)
{
    // 调用 AutoreleasePoolPage 命名空间下的 push 函数
    return AutoreleasePoolPage::push();
}

2.2.1、AutoreleasePoolPage

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.
   每个指针要么是一个要开释的目标，要么是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.
   池令牌是指向该池的POOL_BOUNDARY的指针。当池被弹出，每个比岗兵热的目标都被开释
   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. 
   线程本地存储指向热页，其间存储新主动开释的目标
**********************************************************************/

AutoreleasePoolPage 承继于AutoreleasePoolPageData（有用的内容根本都在 AutoreleasePoolPageData 结构体中）

class AutoreleasePoolPage : private AutoreleasePoolPageData
{
	friend struct thread_data_t;
public:
	static size_t const SIZE =
#if PROTECT_AUTORELEASEPOOL
		PAGE_MAX_SIZE;  // must be multiple of vm page size
#else
		PAGE_MIN_SIZE;  // size and alignment, power of 2
#endif
private:
	static pthread_key_t const key = AUTORELEASE_POOL_KEY;
	static uint8_t const SCRIBBLE = 0xA3;  // 0xA3A3A3A3 after releasing
	static size_t const COUNT = SIZE / sizeof(id);
    static size_t const MAX_FAULTS = 2;
    ...
}

2.2.2、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;
	__unsafe_unretained id *next;
	pthread_t const thread;
	AutoreleasePoolPage * const parent;
	AutoreleasePoolPage *child;
	uint32_t const depth;
	uint32_t hiwat;
	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)
	{
	}
};

结构体中，包括以下成员变量：（根据下边的成员巨细得出 一个page占56字节）

magic：用来校验 AutoreleasePoolPage 的结构是否完好（16字节）
next：指向最新增加的autoreleased目标的下一个方位，初始化时执行begin()：获取目标压栈的开端方位（8字节）
thread：指向当时线程（8字节）
parent：指向父节点，第一个节点的parent值为nil（8字节）
child：指向子节点，最终一个节点的child值为nil（8字节）
depth：代表深度，从0开端，往后递加1（4字节）
hiwat：代表high water mark最大入栈数量符号（4字节）

2.2.3、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;
}

DebugPoolAllocation：当主动开释池按次序弹出时中止，并允许堆调试器跟踪主动开释池
不存在，调用autoreleaseNewPage函数，从一个新的池页开端创立
否则，调用autoreleaseFast函数，将岗兵目标压栈

`autoreleaseFast`

若存在 page，且未存满，调用add函数
若存在 page，但已存满，调用autoreleaseFullPage函数
1. 遍历链表，找到最终一个空白的子页面
2. 对其进行创立新页
3. 设置为热页面
4. 增加目标
不存在 page，调用autoreleaseNoPage函数
1. 调用 AutoreleasePoolPage 结构函数，创立新页
  - 经过父类 AutoreleasePoolPageData 进行初始化
  - begin：获取目标压栈的开端方位（sizeof(*this)：巨细取决于本身结构体中的成员变量、返回目标可压栈的真正开端地址，在成员变量以下）
  - objc_thread_self：经过tls获取当时线程
  - 链接双向链表
2. 设置为热页面
3. pushExtraBoundary为YES，岗兵目标压栈
4. 目标压栈

2.2.4、池页容量

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        for (int i = 0; i < 505; i++) {
            NSObject *objc = [[[NSObject alloc] init] autorelease];
        }
        _objc_autoreleasePoolPrint();
    }
    return 0;
}
-------------------------
objc[1804]: ##############
objc[1804]: AUTORELEASE POOLS for thread 0x1000ebe00
objc[1804]: 506 releases pending.
objc[1804]: [0x10200c000]  ................  PAGE (full)  (cold)
objc[1804]: [0x10200c038]  ################  POOL 0x10200c038
objc[1804]: [0x10200c040]       0x100638420  NSObject
objc[1804]: [0x10200c048]       0x100637a40  NSObject
objc[1804]: [0x10200c050]       0x100636970  NSObject
...
objc[1804]: [0x100809000]  ................  PAGE  (hot) 
objc[1804]: [0x100809038]       0x10063a0b0  NSObject
objc[1804]: ##############

505 个 NSObject 目标循环参加主动开释池，当存储 504 个目标时，池页已满，第 505 个目标创立新池页存储
一页的容量：504 * 8 = 4032，加上56字节成员变量和8字节岗兵目标，合计4096字节
每一页都存在56字节的成员变量
一个主动开释池，只会压栈一个岗兵目标

2.3、objc_autoreleasePoolPop

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

2.3.1、pop（目标出栈）

static inline void
pop(void *token)
{
    AutoreleasePoolPage *page;
    id *stop;
    //判别当时目标是否为空占位符
    if (token == (void*)EMPTY_POOL_PLACEHOLDER) {
        // Popping the top-level placeholder pool.
        //获取热页面
        page = hotPage();
        if (!page) {
            // Pool was never used. Clear the placeholder.
            //不存在热页面，将符号设置为nil
            return setHotPage(nil);
        }
        // Pool was used. Pop its contents normally.
        // Pool pages remain allocated for re-use as usual.
        //存在热页面，经过双向链表循环向上找到最冷页面
        page = coldPage();
        //将token设置为开端方位
        token = page->begin();
    } else {
        //获取token地点的页
        page = pageForPointer(token);
    }
    //赋值给stop
    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
            //最冷页面的开端可能不是POOL_BOUNDARY:
            //1. 弹出尖端池，保存冷页面
            //2. 目标在没有池的情况下被主动开释
        } 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);
}

2.3.2、popPage

static void
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
        //特殊情况:在逐页池调试期间删除一切内容
        //获取父页面
        AutoreleasePoolPage *parent = page->parent;
        //毁掉当时页面
        page->kill();
        //将父页面设置为热页面
        setHotPage(parent);
    } else if (allowDebug && DebugMissingPools  &&  page->empty()  &&  !page->parent) {
        // special case: delete everything for pop(top)
        // when debugging missing autorelease pools
        //特殊情况:删除一切的pop
        //毁掉当时页面
        page->kill();
        //将热页面符号设置为nil
        setHotPage(nil);
    } 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();
        }
    }
}

2.3.3、releaseUntil

void releaseUntil(id *stop)
{
    // Not recursive: we don't want to blow out the stack 
    // if a thread accumulates a stupendous amount of garbage
    //向下遍历，到stop中止
    while (this->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->parent;
            //符号为热页面
            setHotPage(page);
        }
        page->unprotect();
#if SUPPORT_AUTORELEASEPOOL_DEDUP_PTRS
        AutoreleasePoolEntry* entry = (AutoreleasePoolEntry*) --page->next;
        // create an obj with the zeroed out top byte and release that
        id obj = (id)entry->ptr;
        int count = (int)entry->count;  // grab these before memset
#else
        //内存平移，获取目标
        id obj = *--page->next;
#endif
        memset((void*)page->next, SCRIBBLE, sizeof(*page->next));
        page->protect();
        //当时目标不是岗兵目标
        if (obj != POOL_BOUNDARY) {
#if SUPPORT_AUTORELEASEPOOL_DEDUP_PTRS
            // release count+1 times since it is count of the additional
            // autoreleases beyond the first one
            for (int i = 0; i < count + 1; i++) {
                objc_release(obj);
            }
#else
            //将其开释
            objc_release(obj);
#endif
        }
    }
    //将当时页面符号为热页面
    setHotPage(this);
#if DEBUG
    // we expect any children to be completely empty
    for (AutoreleasePoolPage *page = child; page; page = page->child) {
        ASSERT(page->empty());
    }
#endif
}

2.3.4、kill

 void kill()
{
    // Not recursive: we don't want to blow out the stack
    // if a thread accumulates a stupendous amount of garbage
    AutoreleasePoolPage *page = this;
    //循环找到最终一个子页面
    while (page->child) page = page->child;
    AutoreleasePoolPage *deathptr;
    do {
        deathptr = page;
        //找到父页面
        page = page->parent;
        if (page) {
            //将子页面设置为nil
            page->unprotect();
            page->child = nil;
            page->protect();
        }
        //毁掉子页面
        delete deathptr;
        //遍历毁掉到this中止
    } while (deathptr != this);
}

3、嵌套运用

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        NSObject *objc = [[[NSObject alloc] init] autorelease];
        @autoreleasepool {
            NSObject *objc = [[[NSObject alloc] init] autorelease];
        }
        _objc_autoreleasePoolPrint();
    }
    return 0;
}
-------------------------
objc[2511]: ##############
objc[2511]: AUTORELEASE POOLS for thread 0x1000ebe00
objc[2511]: 4 releases pending.
objc[2511]: [0x10680d000]  ................  PAGE  (hot) (cold)
objc[2511]: [0x10680d038]  ################  POOL 0x10680d038
objc[2511]: [0x10680d040]       0x101370c40  NSObject
objc[2511]: [0x10680d048]  ################  POOL 0x10680d048
objc[2511]: [0x10680d050]       0x101365fb0  NSObject
objc[2511]: ##############

线程的主动开释池是一个指针仓库，当嵌套运用时，增加好各自仓库的岗兵目标；出栈时，先开释内部，再开释外部

总结

结构：

主动开释池的压栈和出栈，经过结构体的结构函数和析构函数触发
压栈：调用objc_autoreleasePoolPush函数
出栈：调用objc_autoreleasePoolPop函数

特点：

主动开释池是一个存储指针的栈结构
指针要么是一个要开释的目标，要么是POOL_BOUNDARY主动开释池鸿沟，俗称：岗兵目标
岗兵目标的效果：当主动开释池将目标进行pop操作时，需求知道鸿沟在哪里，否则会损坏别人的内存空间。而岗兵目标，便是鸿沟标识
主动开释池的栈空间被分红一个 双链接 结构的页面列表，可增加和删除页面
双向链表的特别，一个页中同时存在父节点和子节点。可向前找到父页面，也可向后找到子页面
线程本地存储指向热页，其间存储新主动开释的目标
栈原则，先进后出，能够理解为最终一个页面便是热页。里边的目标最终被push，最先被pop

容量：

池页巨细为4096字节，每一页都包括56字节的成员变量，但一个主动开释池中，只会压栈一个岗兵目标，占8字节

原理：

主动开释池的本质是__AtAutoreleasePool结构体，包括结构函数和析构函数
结构体声明，触发结构函数，调用objc_autoreleasePoolPush函数，本质是目标压栈的push办法
当结构体出效果域空间，触发析构函数，调用objc_autoreleasePoolPop函数，本质是目标出栈的pop办法
目标压栈
- 假如存在page，并且没有存满，调用add函数
  - 运用*next++进行内存平移
  - 将目标压栈
  - 假如存在page，但存储已满，调用autoreleaseFullPage函数
  - 遍历链表，找到最终一个空白的子页面
  - 对其进行创立新页
  - 设置为热页面
  - 增加目标
- 否则，不存在page，调用autoreleaseNoPage函数
  - 经过父类AutoreleasePoolPageData进行初始化
  - begin：获取目标压栈的开端方位
  - objc_thread_self：经过tls获取当时线程
  - 链接双向链表
  - 设置为热页面
  - pushExtraBoundary为YES，岗兵目标压栈
  - 目标压栈
目标出栈
- 调用popPage函数，传入stop为岗兵目标的方位
- 当时页中目标出栈，到stop方位中止
- 调用kill函数，毁掉当时页面

嵌套运用：

线程的主动开释池是一个指针仓库，当嵌套运用时，增加好各自仓库的岗兵目标。出栈时，先开释内部，再开释外部

ARC形式：

ARC形式，运用alloc、new、copy、mutableCopy前缀开头的办法进行目标创立，不会参加到主动开释池；它们的空间开辟由开发者申请，开释也由开发者进行办理

与线程的关系：

每个线程（包括主线程）保护自己的目标仓库。随着新池的创立，它们被增加到仓库的顶部。当池被开释时，它们会从仓库中移除
autoreleased目标被放置在当时线程的顶部主动开释池中；当一个线程停止时，它会主动清空一切与其关联的主动开释池

与 Runloop 的关系：

主程序在事情循环的每个循环开端时在主线程上创立一个主动开释池
并在结束时将其排空，从而开释在处理事情时生成的任何主动开释目标

运用：

for循环中大量创立目标时，运用 autorelease 能够有效控制内存的快速增长（原因是开释没有创立快，假如不加 autorelease 最终内存也会降下来，但能够 削减内存峰值）
```
for (int i = 0; i<100000000; i++) {
    @autoreleasepool {
        NSLog(@"%d",i);
        __autoreleasing LZPerson *p =[LZPerson new];
    }
}
```

iOS底层探索-自动释放池

1、概述

2、底层探索

2.1、打印主动开释池结构

2.2、objc_autoreleasePoolPush

2.2.1、AutoreleasePoolPage

2.2.2、AutoreleasePoolPageData

2.2.3、push（目标压栈）

autoreleaseFast

2.2.4、池页容量

2.3、objc_autoreleasePoolPop

2.3.1、pop（目标出栈）

2.3.2、popPage

2.3.3、releaseUntil

2.3.4、kill

3、嵌套运用

总结

相关文章

『牛客|每日一题』N皇后问题

努力做最好的自己，其他的交给天意（关于高考）

在 Goland 中使用 git rebase 提前解决冲突

磁盘原理简要分析

作者信息

`autoreleaseFast`