本章提纲：
1、自动释放池的初识
2、自动释放池的数据结构
3、自动释放池的源码分析
1.自动释放池的初识
从main函数开始
main函数在iOS开发中，可以说是一个非常不显眼的存在，它隐藏在main.m文件中，是整个应用程序的入口，有着非常重要的作用。我们常见到的main函数中的内容如下：
可以看到几行简短的代码，其中
@autoreleasepool就是我们今天要重点去探究的内容，来看看@autoreleasepool到底是什么。我们通过两种方式来研究下它的本质。
- Clang编译查看
我们通过命令
xcrun -sdk iphonesimulator clang -rewrite-objc main.m
生成相应的.cpp文件，编译完如下：
原来的
@autoreleasepool被注释掉了，随之用__AtAutoreleasePool替代了，搜索下这个关键字，发现它的定义如下：
struct __AtAutoreleasePool {
__AtAutoreleasePool() {atautoreleasepoolobj = objc_autoreleasePoolPush();}
~__AtAutoreleasePool() {objc_autoreleasePoolPop(atautoreleasepoolobj);}
void * atautoreleasepoolobj;
};
这个定义其实是封装了构造函数和析构函数，举个一样的例子，我们定义一结构体Lucky如下：
struct Lucky {
Lucky(){
printf("22222222\n");
}
~Lucky(){
printf("1111111");
}
};
来看调试过程：
当我们调用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的节点之前进行遍历，并释放对象。
实例扩展
之前在项目中使用过自动释放池降低内存峰值。如果在短时间内创建大量的临时变量，那么会导致内存峰值增大，使用自动释放池可以有效的降低峰值。原因是自己创建个池子大量的临时变量就在自己的池子里了，而不是线程的主池里。
