概念

AutoreleasePool（自动释放池）是OC中的一种内存自动回收机制，它可以延迟加入AutoreleasePool中的变量release的时机。在正常情况下，创建的变量会在超出其作用域的时候release，但是如果将变量加入AutoreleasePool，那么release将延迟执行。

App启动后，苹果在主线程 RunLoop里注册了两个 Observer，其回调都是 _wrapRunLoopWithAutoreleasePoolHandler()，从程序启动到加载完成，主线程对应的runloop会处于休眠状态，等待用户交互来唤醒runloop
- 第一个 Observer 监视的事件是 Entry(即将进入Loop)，其回调内会调用 _objc_autoreleasePoolPush()创建自动释放池。优先级最高，保证创建释放池发生在其他所有回调之前
- 第二个 Observer监视了两个事件：BeforeWaiting(准备进入休眠) 时调用_objc_autoreleasePoolPop() 和 _objc_autoreleasePoolPush()释放旧的池并创建新池；Exit(即将退出Loop) 时调用 _objc_autoreleasePoolPop()来释放自动释放池。优先级最低，保证其释放池子发生在其他所有回调之后。
用户的每一次交互都会启动一次runloop，用于处理用户的所有点击、触摸事件等
runloop在监听到交互事件后，就会创建自动释放池，并将所有延迟释放的对象添加到自动释放池中
主线程执行的代码，通常是写在诸如事件回调、Timer回调内的。这些回调会被RunLoop创建好的 AutoreleasePool环绕着，所以不会出现内存泄漏，开发者也不必显示创建 Pool了。
在一次完整的runloop结束之前，会向自动释放池中所有对象发送release消息，然后销毁自动释放池

clang 分析

int main(int argc, char * argv[]) {@autoreleasepool {}
}

通过clang编译成cpp文件插看实现：
xcrun -sdk iphonesimulator clang -arch x86_64 -rewrite-objc main.m

int main(int argc, char * argv[]) {/* @autoreleasepool */ {__AtAutoreleasePool __autoreleasepool; }
}struct __AtAutoreleasePool {__AtAutoreleasePool() {atautoreleasepoolobj = objc_autoreleasePoolPush();}~__AtAutoreleasePool() {objc_autoreleasePoolPop(atautoreleasepoolobj);}void * atautoreleasepoolobj;
};

通过代码可以看出autoreleasepool在底层实际是调用__AtAutoreleasePool，而__AtAutoreleasePool本质上是一个结构体，其内部包含构造函数__AtAutoreleasePool()与析构函数~__AtAutoreleasePool()，在{}作用域结束后会自动调用析构函数，以便及时创建销毁

###汇编分析

struct LGTest {LGTest(){printf("1123 - %s",__func__);}~LGTest(){printf("5667 - %s",__func__);}
};int main(int argc, char * argv[]) {LGTest LGTest;
}

在main函数中添加断点查看汇编

可以看出跟clang编译后一样都是经过objc_autoreleasePoolPush与objc_autoreleasePoolPop

底层原理

在objc源码中是这样注释的

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.
线程本地存储指向热页面，该页面存储新自动释放的对象。

查看源码

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

通过代码可以看出push与pop操作都是基于AutoreleasePoolPage，根据其定义看出自动释放池是页结构，每页的大小为4096字节

//************宏定义************
#define PAGE_MIN_SIZE           PAGE_SIZE
#define PAGE_SIZE               I386_PGBYTES
#define I386_PGBYTES            4096            /* bytes per 80386 page *///************类定义************
class AutoreleasePoolPage : private AutoreleasePoolPageData
{friend struct thread_data_t;public://页的大小static size_t const SIZE =
#if PROTECT_AUTORELEASEPOOLPAGE_MAX_SIZE;  // must be multiple of vm page size
#elsePAGE_MIN_SIZE;  // size and alignment, power of 2
#endifprivate:...//构造函数AutoreleasePoolPage(AutoreleasePoolPage *newParent) :AutoreleasePoolPageData(begin(),//开始存储的位置objc_thread_self(),//传的是当前线程，当前线程时通过tls获取的newParent,newParent ? 1+newParent->depth : 0,//如果是第一页深度为0，往后是前一个的深度+1newParent ? newParent->hiwat : 0){...}//析构函数~AutoreleasePoolPage() {...}...//页的开始位置id * begin() {...}//页的结束位置id * end() {...}//页是否为空bool empty() {...}//页是否满了bool full() {...}//页的存储是否少于一半bool lessThanHalfFull() {...}//添加释放对象id *add(id obj){...}//释放所有对象void releaseAll() {...}//释放到stop位置之前的所有对象void releaseUntil(id *stop) {...}//杀掉void kill() {...}//释放本地线程存储空间static void tls_dealloc(void *p) {...}//获取AutoreleasePoolPagestatic AutoreleasePoolPage *pageForPointer(const void *p) {...}static AutoreleasePoolPage *pageForPointer(uintptr_t p)  {...}//是否有空池占位符static inline bool haveEmptyPoolPlaceholder() {...}//设置空池占位符static inline id* setEmptyPoolPlaceholder(){...}//获取当前操作页static inline AutoreleasePoolPage *hotPage(){...}//设置当前操作页static inline void setHotPage(AutoreleasePoolPage *page) {...}//获取coldPagestatic inline AutoreleasePoolPage *coldPage() {...}//快速释放static inline id *autoreleaseFast(id obj){...}//添加自动释放对象，当页满的时候调用这个方法static __attribute__((noinline))id *autoreleaseFullPage(id obj, AutoreleasePoolPage *page) {...}//添加自动释放对象，当没页的时候使用这个方法static __attribute__((noinline))id *autoreleaseNoPage(id obj){...}//创建新页static __attribute__((noinline))id *autoreleaseNewPage(id obj) {...}public://自动释放static inline id autorelease(id obj){...}//入栈static inline void *push() {...}//兼容老的 SDK 出栈方法__attribute__((noinline, cold))static void badPop(void *token){...}//出栈页面template<bool allowDebug>static voidpopPage(void *token, AutoreleasePoolPage *page, id *stop){...}__attribute__((noinline, cold))static voidpopPageDebug(void *token, AutoreleasePoolPage *page, id *stop){...}//出栈static inline voidpop(void *token){...}static void init(){...}//打印__attribute__((noinline, cold))void print(){...}//打印所有__attribute__((noinline, cold))static void printAll(){...}//打印Hiwat__attribute__((noinline, cold))static void printHiwat(){...}

根据代码可以看出AutoreleasePoolPage继承与AutoreleasePoolPageData

struct AutoreleasePoolPageData
{magic_t const magic; // 内存大小为m[4];所占内存（即4*4=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){}
};

magic 用来校验AutoreleasePoolPage 的结构是否完整;
next指向最新添加的 autoreleased对象的下一个位置，初始化时指向
begin();
thread 指向当前线程;
parent指向父结点，第一个结点的 parent 值为nil ;
child指向子结点，最后一个结点的child值为 nil ;
depth代表深度，从 0开始，往后递增1;
hiwat 代表 high water mark 最大入栈数量标记

根据变量看出其中包含parent与child，两者相互存在关系，可以得出是一个双向链表结构

#####push

//入栈
static inline void *push()
{id *dest;//判断是否有poolif (slowpath(DebugPoolAllocation)) {// Each autorelease pool starts on a new pool page.自动释放池从新池页面开始//如果没有，则创建dest = autoreleaseNewPage(POOL_BOUNDARY);} else {//压栈一个POOL_BOUNDARY，即压栈哨兵dest = autoreleaseFast(POOL_BOUNDARY);}ASSERT(dest == EMPTY_POOL_PLACEHOLDER || *dest == POOL_BOUNDARY);return dest;
}

通过代码可以看出，通判断是否存在pool，如果存在直接压栈，如果没有则需要创建

创建方法

//创建新页
static __attribute__((noinline))
id *autoreleaseNewPage(id obj)
{//获取当前操作页AutoreleasePoolPage *page = hotPage();//如果存在，则压栈对象if (page) return autoreleaseFullPage(obj, page);//如果不存在，则创建页else return autoreleaseNoPage(obj);
}//获取当前操作页
static inline AutoreleasePoolPage *hotPage()
{//获取当前页AutoreleasePoolPage *result = (AutoreleasePoolPage *)tls_get_direct(key);//如果是一个空池，则返回nil，否则，返回当前线程的自动释放池if ((id *)result == EMPTY_POOL_PLACEHOLDER) return nil;if (result) result->fastcheck();return result;
}//******** autoreleaseNoPage方法 ********
static __attribute__((noinline))
id *autoreleaseNoPage(id obj)
{// "No page" could mean no pool has been pushed// or an empty placeholder pool has been pushed and has no contents yetASSERT(!hotPage());bool pushExtraBoundary = false;//判断是否是空占位符，如果是，则压栈哨兵标识符置为YESif (haveEmptyPoolPlaceholder()) {// We are pushing a second pool over the empty placeholder pool// or pushing the first object into the empty placeholder pool.// Before doing that, push a pool boundary on behalf of the pool // that is currently represented by the empty placeholder.pushExtraBoundary = true;}//如果对象不是哨兵对象，且没有Pool，则报错else if (obj != POOL_BOUNDARY  &&  DebugMissingPools) {// We are pushing an object with no pool in place, // and no-pool debugging was requested by environment._objc_inform("MISSING POOLS: (%p) Object %p of class %s ""autoreleased with no pool in place - ""just leaking - break on ""objc_autoreleaseNoPool() to debug", objc_thread_self(), (void*)obj, object_getClassName(obj));objc_autoreleaseNoPool(obj);return nil;}//如果对象是哨兵对象，且没有申请自动释放池内存，则设置一个空占位符存储在tls中，其目的是为了节省内存else if (obj == POOL_BOUNDARY  &&  !DebugPoolAllocation) {//如果传入参数为哨兵// We are pushing a pool with no pool in place,// and alloc-per-pool debugging was not requested.// Install and return the empty pool placeholder.return setEmptyPoolPlaceholder();//设置空的占位符}// We are pushing an object or a non-placeholder'd pool.// Install the first page.//初始化第一页AutoreleasePoolPage *page = new AutoreleasePoolPage(nil);//设置page为当前聚焦页setHotPage(page);// Push a boundary on behalf of the previously-placeholder'd pool.//压栈哨兵的标识符为YES，则压栈哨兵对象if (pushExtraBoundary) {//压栈哨兵page->add(POOL_BOUNDARY);}// Push the requested object or pool.//压栈对象return page->add(obj);
}

通过代码得知逻辑为：

通过hotPage获取当前操作页
- 如果存在，则通过autoreleaseFullPage直接将对象进行压栈
- 如果不存在，则通过autoreleaseNoPage创建页

//********begin()********
//页的开始位置
id * begin() {//等于 首地址+56（AutoreleasePoolPage类所占内存大小）return (id *) ((uint8_t *)this+sizeof(*this));
}

根据代码得知begin()是页的起始位置即存储对象的起始位置，由于AutoreleasePoolPageData是一个结构体，存储对象的话需要将AutoreleasePoolPageData的地址进行平移结构体的大小才能开始存储，上面分析其属性时可以得出共56字节，故而begin（）地址为首地址+56

######验证
由于在ARC模式下，是无法手动调用autorelease，所以将Demo切换至MRC模式（Build Settings -> Objectice-C Automatic Reference Counting设置为NO）

//************打印自动释放池结构************
extern void _objc_autoreleasePoolPrint(void);//************运行代码************
int main(int argc, const char * argv[]) {@autoreleasepool {//循环创建对象，并加入自动释放池for (int i = 0; i < 5; i++) {NSObject *objc = [[NSObject alloc] sutorelease];}//调用_objc_autoreleasePoolPrint();}
}

根据代码可以看出，本质上应该只打印5个对象，但实际上打印内容多出一个POOL，其就表示哨兵，为了防止越界
并且查看对应地址时，可以看出起始位置为0x100817000，但是哨兵的位置为0x100817038，根据十六进制计算得出38=3*16+8 = 56，这样也可以验证begin（）起始位置是经过内存平移56个字节

通过更改i的大小可以发现，当i为504时正好一页存储，而当i为505时，就需要两页，但是第二页中只有对象，并没有哨兵，这样就可以得知，哨兵在自动释放池中只存在一个，且在第一页，每页存储的数据为505个，第一页为504个对象+哨兵，其他页为505个对象，因为每页内存大小为4096字节，就可以得出：505* 8 = 4040 + 56 = 4096

####压栈

根据上面push代码可以得知，当没有页时是创建页，而当有页时，直接压栈

static inline id *autoreleaseFast(id obj)
{//获取当前操作页AutoreleasePoolPage *page = hotPage();//判断页是否满了if (page && !page->full()) {//如果未满，则压栈return page->add(obj);} else if (page) {//如果满了，则安排新的页面return autoreleaseFullPage(obj, page);} else {//页不存在，则新建页return autoreleaseNoPage(obj);}
}

压栈时，首先判断当前页是否满了，如果未满直接压栈，如果满了则需创建新页面

//添加自动释放对象，当页满的时候调用这个方法
static __attribute__((noinline))
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-while遍历循环查找界面是否满了do {//如果子页面存在，则将页面替换为子页面if (page->child) page = page->child;//如果子页面不存在，则新建页面else page = new AutoreleasePoolPage(page);} while (page->full());//设置为当前操作页面setHotPage(page);//对象压栈return page->add(obj);
}

添加释放对象: 底层是实现是通过next指针存储释放对象，并将next指针递增，表示下一个释放对象存储的位置。从这里可以看出页是通过栈结构存储

//添加释放对象
id *add(id obj)
{ASSERT(!full());unprotect();//传入对象存储的位置id *ret = next;  // faster than `return next-1` because of aliasing//将obj压栈到next指针位置，然后next进行++，即下一个对象存储的位置*next++ = obj;protect();return ret;
}

####pop
在objc_autoreleasePoolPop方法中有个参数，在clang分析时，发现传入的参数是push压栈后返回的哨兵对象，即ctxt，其目的是避免出栈混乱，防止将别的对象出栈

//出栈
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.//如果当前页不存在，则清除空占位符return setHotPage(nil);}// Pool was used. Pop its contents normally.// Pool pages remain allocated for re-use as usual.//如果当前页存在，则将当前页设置为coldPage,token设置为coldPage的开始位置page = coldPage();token = page->begin();} else {//获取token所在的页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} 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);
}

传入的allowDebug为false，则通过releaseUntil出栈当前页stop位置之前的所有对象，即向栈中的对象发送release消息，直到遇到传入的哨兵对象

//出栈页面
template<bool allowDebug>static voidpopPage(void *token, AutoreleasePoolPage *page, id *stop)
{if (allowDebug && PrintPoolHiwat) printHiwat();//出栈当前操作页面对象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（top）的所有内容page->kill();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();}}
}

进入releaseUntil实现，主要是通过循环遍历，判断对象是否等于stop，其目的是释放stop之前的所有的对象，
首先通过获取page的next释放对象（即page的最后一个对象），并对next进行递减，获取上一个对象
判断是否是哨兵对象，如果不是则自动调用objc_release释放

//释放到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//判断下一个对象是否等于stop，如果不等于，则进入while循环while (this->next != stop) {// Restart from hotPage() every time, in case -release // autoreleased more objects 每次从hotPage（）重新启动，以防-release自动释放更多对象//获取当前操作页面，即hot页面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();//next进行--操作，即出栈id obj = *--page->next;//将页索引位置置为SCRIBBLE，表示已经被释放memset((void*)page->next, SCRIBBLE, sizeof(*page->next));page->protect();if (obj != POOL_BOUNDARY) {//释放objc_release(obj);}}//设置当前页setHotPage(this);#if DEBUG// we expect any children to be completely emptyfor (AutoreleasePoolPage *page = child; page; page = page->child) {ASSERT(page->empty());}
#endif
}

进入kill实现，主要是销毁当前页，将当前页赋值为父节点页，并将父节点页的child对象指针置为nil

//销毁
void kill()
{// Not recursive: we don't want to blow out the stack // if a thread accumulates a stupendous amount of garbageAutoreleasePoolPage *page = this;//获取最后一个页while (page->child) page = page->child;AutoreleasePoolPage *deathptr;do {deathptr = page;//子节点 变成 父节点page = page->parent;if (page) {page->unprotect();//子节点为nilpage->child = nil;page->protect();}delete deathptr;} while (deathptr != this);
}

#总结

在自动释放池的压栈（即push）操作中
当没有pool，即只有空占位符（存储在tls中）时，则创建页，压栈哨兵对象
在页中压栈普通对象主要是通过next指针递增进行的，
当页满了时，需要设置页的child对象为新建页
在自动释放池的出栈（即pop）操作中
在页中出栈普通对象主要是通过next指针递减进行的，
当页空了时，需要赋值页的parent对象为当前页

图片来源月月

AutoReleasePool 底层原理相关推荐

iOS底层原理 - 常驻线程
iOS底层原理 - 常驻线程在 AFN 2.0 时代,会经常看到 AFN 创建一个常驻线程的方式: 0️⃣ AFN 2.0 时代的常驻线程 + (NSThread *)networkRequestT ...
iOS底层原理之内存管理
文章目录定时器 CADisplayLink.NSTimer GCD定时器内存管理 iOS程序的内存布局 Tagged Pointer OC对象的内存管理拷贝引用计数的存储 dealloc 自动 ...
没有与参数列表匹配的重载函数 getline 实例_面试题：方法重载的底层原理？...
前语:微信改版后,大量读者还没养成点赞的习惯,如写得好,望大家阅读后在右下边"好看"处点个赞,以示鼓励!长期坚持原创真的很不容易,多次想放弃,坚持是一种信仰,专注是一种态度. 关于 ...
synchronized底层原理_你用过synchronized吗？它的底层原理是什么？Java经典面试题来了...
并发编程已经成为程序员必备技能作为Java程序员,不懂得并发编程显然已经不能满足市场需求了,尤其是在面试过程中将处于被动地位,也有可能面试将就此终结. 那么作为Java开发者的你,日常虽然可以基于J ...
elasticsearch原理_ElasticSearch读写底层原理及性能调优
ES写入/查询底层原理 1. Elasticsearch写入数据流程客户端随机选择一个ES集群中的节点,发送POST/PUT请求,被选择的节点为协调节点(coordinating node) 协调节 ...
嘿嘿，我就知道面试官接下来要问我 ConcurrentHashMap 底层原理了，看我怎么秀他...
来自:烟雨星空前言上篇文章介绍了 HashMap 源码后,在博客平台广受好评,让本来己经不打算更新这个系列的我,仿佛被打了一顿鸡血.真的,被读者认可的感觉,就是这么奇妙. 原文:面试官再问你 Ha ...
面试官再问你 HashMap 底层原理，就把这篇文章甩给他看
来自:烟雨星空前言 HashMap 源码和底层原理在现在面试中是必问的.因此,我们非常有必要搞清楚它的底层实现和思想,才能在面试中对答如流,跟面试官大战三百回合.文章较长,介绍了很多原理性的问题,希 ...
为了把mysql的索引底层原理讲清楚，我把计算机翻了个底朝天
来自:非科班的科班什么是索引概念:索引是提高mysql查询效率的数据结构.总的一句话概括就是索引是一种数据结构. 数据库查询是数据库的最主要功能之一.设计者们都希望查询数据的速度能尽可能的快,因此 ...
面试官：说说Spring Cloud底层原理?
点击上方"蓝字", 右上角选择"设为星标" 周一至周五上午11:45!精品文章准时送上! 本文转载自公众号:石杉的架构笔记目录一.业务场景介绍二.Spri ...

AutoReleasePool 底层原理

概念

clang 分析

底层原理

AutoReleasePool 底层原理相关推荐

最新文章

热门文章