AutoReleasePool 自动释放池
自动释放池 -> 内存自动回收机制 -> 变量release的时机延迟
对象 -> 正常情况下，变量会在超出其作用域的时立即release -> 加入到了自动释放池中 -> 不会立即释放，会等到runloop休眠/超出autoreleasepool作用域{}之后才会被释放
- 从程序启动到加载完成，主线程对应的runloop会处于休眠状态，等待用户交互来唤醒runloop
- 用户的每一次交互都会启动一次runloop，用于处理用户的所有点击、触摸事件等
- runloop在监听到交互事件后，就会创建自动释放池，并将所有延迟释放的对象添加到自动释放池中
- 在一次完整的runloop结束之前，会向自动释放池中所有对象发送release消息，然后销毁自动释放池
Clang分析AutoReleasePool
- __AtAutoreleasePool是一个结构体，有构造函数 + 析构函数，结构体定义的对象在作用域结束后，会自动调用析构函数
- 其中{} 是 作用域 ，优点是结构清晰，可读性强，可以及时创建销毁
//构造函数 + 析构函数举例说明 struct CJLTest{ CJLTest (){ printf("1123 - %s\n", __func__); } ~CJLTest(){ printf("5667 - %s\n", __func__); } }; int main(int argc, const char * argv[]) { { CJLTest test; } } //**********运行结果********** 1123 - CJLTest 5667 - ~CJLTest
CJLTest创建对象时，会自动调用构造函数，在出了{}作用域后，会自动调用析构函数
汇编分析
- autoreleasepool -> 结构体对象，一个自动释放池对象就是页 -> 栈结构存储，符合先进后出的原则即可
- 页的栈底是一个56字节大小的空占位符，一页总大小为4096字节
- 只有第一页有哨兵对象，最多存储504个对象，从第二页开始最多存储505个对象
- autoreleasepool在加入要释放的对象时 -> 底层调用的是
objc_autoreleasePoolPush方法 - autoreleasepool在调用析构函数释放时 -> 内部的实现是调用objc_autoreleasePoolPop方法
底层分析
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. 线程本地存储指向热页面，该页面存储新自动释放的对象。
对以上的解释说明:
- 自动释放池 是一个 关于指针的栈结构
- 指针是指要释放的对象或者 pool_boundary 哨兵（现在经常被称为 边界）
- 自动释放池是一个页的结构（虚拟内存中提及过） ，而且这个页是一个双向链表（表示有父节点 和 子节点，在类中提及过，即类的继承链）
- 自动释放池和线程有关系
需要注意的地方:
- 自动释放池什么时候创建？
- 对象是如何加入自动释放池的？
- 哪些对象才会加入自动释放池？
AutoreleasePoolPage
//***********push方法*********** void * objc_autoreleasePoolPush(void) { return AutoreleasePoolPage::push(); } //***********pop方法*********** void objc_autoreleasePoolPop(void *ctxt) { AutoreleasePoolPage::pop(ctxt); }
源码 -> 调用的AutoreleasePoolPage的push和pop实现，以下是其定义，从定义中可以看出，自动释放池是一个页，同时也是一个对象，这个页的大小是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_AUTORELEASEPOOL PAGE_MAX_SIZE; // must be multiple of vm page size #else PAGE_MIN_SIZE; // size and alignment, power of 2 #endif private: ... //构造函数 AutoreleasePoolPage(AutoreleasePoolPage *newParent) : AutoreleasePoolPageData(begin(),//开始存储的位置 objc_thread_self(),//传的是当前线程，当前线程时通过tls获取的 newParent, newParent ? 1+newParent->depth : 0,//如果是第一页深度为0，往后是前一个的深度+1 newParent ? 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) {...} //获取AutoreleasePoolPage static 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) {...} //获取coldPage static 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 void popPage(void *token, AutoreleasePoolPage *page, id *stop){...} __attribute__((noinline, cold)) static void popPageDebug(void *token, AutoreleasePoolPage *page, id *stop){...} //出栈 static inline void pop(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,且该类的属性也是来自父类，以下是AutoreleasePoolPageData的定义，
- AutoreleasePoolPage对象，所以有以下一个关系链AutoreleasePoolPage -> AutoreleasePoolPageData -> AutoreleasePoolPage，从这里可以说明自动释放池 -> 页 -> 双向链表结构
class AutoreleasePoolPage; struct AutoreleasePoolPageData { //用来校验AutoreleasePoolPage的结构是否完整 magic_t const magic;//16个字节 //指向最新添加的autoreleased对象的下一个位置，初始化时指向begin() __unsafe_unretained id *next;//8字节 //指向当前线程 pthread_t const thread;//8字节 //指向父节点，第一个结点的parent值为nil AutoreleasePoolPage * const parent;//8字节 //指向子节点，最后一个结点的child值为nil AutoreleasePoolPage *child;//8字节 //表示深度，从0开始，往后递增1 uint32_t const depth;//4字节 //表示high water mark 最大入栈数量标记 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 -> 结构体内存大小56字节
- magic -> magic_t结构体 -> 内存大小为m[4], 所占内存（即4*4=16字节）
- next（指针）、thread（对象）、parent（对象）、child（对象）均占8字节（即4*8=32字节)
- 属性depth、hiwat类型为uint32_t，实际类型是unsigned int类型，均占4字节（即2*4=8字节）
objc_autoreleasePoolPush 源码分析
- 判断是否为有 pool
- 如果没有，则通过autoreleaseNewPage方法创建
- 如果有，则通过autoreleaseFast压栈哨兵对象
//入栈 static inline void *push() { id *dest; //判断是否有pool if (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; }
1. 创建页 autoreleaseNewPage
objc_autoreleasePoolPush -> push -> autoreleaseNewPage
- 通过hotPage`获取当前页，判断当前页是否存在
- 如果存在，则通过autoreleaseFullPage方法压栈对象
- 如果不存在，则通过autoreleaseNoPage方法创建页
//创建新页 static __attribute__((noinline)) id *autoreleaseNewPage(id obj) { //获取当前操作页 AutoreleasePoolPage *page = hotPage(); //如果存在，则压栈对象 if (page) return autoreleaseFullPage(obj, page); //如果不存在，则创建页 else return autoreleaseNoPage(obj); } //******** hotPage方法 ******** //获取当前操作页 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 yet ASSERT(!hotPage()); bool pushExtraBoundary = false; //判断是否是空占位符，如果是，则压栈哨兵标识符置为YES if (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); }
autoreleaseNoPage -> 当前线程的自动释放池是通过AutoreleasePoolPage创建的 -> 构造方法 -> 实现是通过父类AutoreleasePoolPageData的初始化方法
//**********AutoreleasePoolPage构造方法********** AutoreleasePoolPage(AutoreleasePoolPage *newParent) : AutoreleasePoolPageData(begin(),//开始存储的位置 objc_thread_self(),//传的是当前线程，当前线程时通过tls获取的 newParent, newParent ? 1+newParent->depth : 0,//如果是第一页深度为0，往后是前一个的深度+1 newParent ? newParent->hiwat : 0) { if (parent) { parent->check(); ASSERT(!parent->child); parent->unprotect(); //this 表示 新建页面，将当前页面的子节点 赋值为新建页面 parent->child = this; parent->protect(); } protect(); } //**********AutoreleasePoolPageData初始化方法********** 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) { }
- begin()表示压栈的位置（即下一个要释放对象的压栈地址） -> 源码调试begin，发现其具体实现等于页首地址+56，其中的56就是结构体AutoreleasePoolPageData的内存大小
//********begin()******** //页的开始位置 id * begin() { //等于 首地址+56（AutoreleasePoolPage类所占内存大小） return (id *) ((uint8_t *)this+sizeof(*this)); }
- objc_thread_self() 表示的是当前线程，而当前线程时通过tls获取的
__attribute__((const)) static inline pthread_t objc_thread_self() { //通过tls获取当前线程 return (pthread_t)tls_get_direct(_PTHREAD_TSD_SLOT_PTHREAD_SELF); }
- newParent表示父节点
- 后续两个参数是通过父节点的深度、最大入栈个数计算depth以及hiwat
查看自动释放池内存结构
ARC模式下 -> 无法手动调用autorelease -> 切换至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(); } } //6个 -> 压栈的对象其实只有5个，其中的POOL表示哨兵，即边界，其目的是为了防止越界
查看自动释放池的内存结构，发现，页的首地址与哨兵对象相差0x38，转换成十进制刚好是56，也就是 AutoreleasePoolPage自己本身的内存大小
结论
- 第一页可以存放504个对象，且只有第一页有哨兵，当一页压栈满了，就会开辟新的一页
- 第二页开始，最多可以存放505个对象
- 一页的大小等于 505 * 8 = 4040
这个结论同样可以通过AutoreleasePoolPage中的SIZE来得到印证，从其定义中我们可以得出，一页的大小是4096字节，而在其构造函数中对象的压栈位置，是从首地址+56开始的，所以可以一页中实际可以存储4096-56 = 4040字节，转换成对象是4040 / 8 = 505个,即一页最多可以存储505个对象，其中第一页有哨兵对象只能存储504个
问题: 哨兵在一个自动释放池有几个？
- 只有一个哨兵对象，且哨兵在第一页
- 第一页最多可以存504个对象，第二页开始最多存 505个
压栈对象 autoreleaseFast
- 获取当前操作页，并判断页是否存在以及是否满了
- 如果页存在，且未满，则通过add方法压栈对象
- 如果页存在，且满了，则通过autoreleaseFullPage方法安排新的页面
- 如果页不存在，则通过autoreleaseNoPage方法创建新页
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); } }
autoreleaseFullPage 方法
用于判断当前页是否已经存储满了，如果当前页已经满了，通过do-while循环查找子节点对应的页，如果不存在，则新建页，并压栈对象
//添加自动释放对象，当页满的时候调用这个方法 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); }
从AutoreleasePoolPage初始化方法中可以看出，主要是通过操作child对象，将当前页的child指向新建页面，由此可以得出页是通过双向链表连接
add 方法
主要是添加释放对象，其底层是实现是通过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; }
autorelease 底层分析
- 如果不是对象 或者 是小对象，则直接返回
- 如果是对象，则调用对象的autorelease进行释放
__attribute__((aligned(16), flatten, noinline)) id objc_autorelease(id obj) { //如果不是对象，则直接返回 if (!obj) return obj; //如果是小对象，也直接返回 if (obj->isTaggedPointer()) return obj; return obj->autorelease(); }
无论是压栈哨兵对象，还是普通对象，都会来到autoreleaseFast方法，只是区别标识不同而以
objc_autoreleasePoolPop 源码分析
objc_autoreleasePoolPop方法中有个参数，在clang分析时，发现传入的参数是push压栈后返回的哨兵对象，即ctxt，其目的是避免出栈混乱，防止将别的对象出栈
- pop源码实现
- 空页面的处理，并根据token获取page
- 容错处理
- 通过popPage出栈页
- 进入popPage源码，其中传入的allowDebug为false，则通过releaseUntil出栈当前页stop位置之前的所有对象，即向栈中的对象发送release消息，直到遇到传入的哨兵对象
- 进入releaseUntil实现，主要是通过循环遍历，判断对象是否等于stop，其目的是释放stop之前的所有的对象
- 首先通过获取page的next释放对象（即page的最后一个对象），并对next进行递减，获取上一个对象
- 判断是否是哨兵对象，如果不是则自动调用objc_release释放
- 进入kill实现，主要是销毁当前页，将当前页赋值为父节点页，并将父节点页的child对象指针置为nil
总结
- 在自动释放池的压栈（即push）操作中
- 当没有pool，即只有空占位符（存储在tls中）时，则创建页，
压栈哨兵对象 - 在页中压栈普通对象主要是通过
next指针递增进行的 - 当页满了时，需要设置页的child对象为新建页
- 在自动释放池的出栈（即pop）操作中
- 在页中出栈普通对象主要是通过next指针递减进行的
- 当页空了时，需要赋值页的parent对象为当前页
