OC底层原理探索文档汇总
自动释放池是OC中的一种自动垃圾回收机制。属于内存管理的一种方案。
主要内容：
- 自动释放池的认识
- 自动释放池的本质
- 自动释放池的压栈和出栈过程分析
1、自动释放池的认识
1.1 介绍
自动释放池是OC的一种自动垃圾回收机制，用来管理对象的释放。它可以将加入到autoreleasePool中的对象的release时机延迟。
正常情况下，当一个对象停止指向某一个变量时，该对象会立即进行release。但是如果该对象加入到了自动释放池中，这个对象并不会立即release。而是会等到runloop休眠或者超出autoreleasePool作用域{}之后才会被释放。
autoreleasePool的图示.png
说明：
- 从程序启动到加载完成，主线程对应的runloop会处于休眠状态，等待用户交互来唤醒runloop。
- 用户的每一次交互都会唤醒一次runloop，用于处理用户的所有点击、触摸事件等。
- runloop在监听到交互事件后，就会创建自动释放池，并将所有延迟释放的对象添加到自动释放池中。
- 在一次完整的runloop结束之前，会向自动释放池中所有对象发送release消息，然后销毁自动释放池
1.2 查看autoreleasePool的本质
通过Clang进行分析
定义代码：
int main(int argc, const char * argv[]) {
@autoreleasepool {
}
}
查看编译后的结果
struct __AtAutoreleasePool {
__AtAutoreleasePool() {atautoreleasepoolobj = objc_autoreleasePoolPush();}
~__AtAutoreleasePool() {objc_autoreleasePoolPop(atautoreleasepoolobj);}
void * atautoreleasepoolobj;
};
int main(int argc, char * argv[]) {
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
}
}
说明：
- 可以看到在底层其实是使用一个__AtAutoreleasePool结构体来实现的
- 自动释放池的作用范围就是__AtAutoreleasePool()构造成功后到~__AtAutoreleasePool()析构结束，中间的代码就是属于自动释放池{}中执行的代码
- 该结构体构造函数和析构函数分别使用objc_autoreleasePoolPush和objc_autoreleasePoolPop来实现的。
总结：
- 自动释放池本质是一个结构体，是一个类（后续会说明）
- 调用构造函数就是作用域的开始
- 调用析构函数就是作用域的结束
- 其中{} 是 作用域 ，优点是结构清晰，可读性强，可以及时创建销毁
自定义一个结构体来验证作用域
//包括构造函数和析构函数
struct WYTest{
WYTest(){
printf("作用域开始 - %s\n", __func__);
}
~WYTest(){
printf("作用域结束 - %s\n", __func__);
}
};
int main(int argc, char * argv[]) {
{
printf("WY:嘿嘿-作用域前 - %s\n", __func__);
WYTest test;
printf("WY：哈哈-作用域中 - %s\n", __func__);
}
printf("WY：嘻嘻- 作用域后 - %s\n", __func__);
}
运行结果：
WY:嘿嘿-作用域前 - main
作用域开始 - WYTest
WY：哈哈-作用域中 - main
作用域结束 - ~WYTest
WY：嘻嘻- 作用域后 - main
说明：
- 可以看到作用域的范围就是构造函数和析构函数中间的范围
- 在{}中执行WYTest test，那么这个{}范围就是从这条语句之后到该代码块结束
2、底层分析
2.1 首先看下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.
线程本地存储指向热页面，该页面存储新自动释放的对象。
说明：
- 自动释放池是依赖于线程的。线程拥有自动释放池（基于RunLoop管理）。
- 自动释放池本质是一个存储有指针的栈，指针包含对象指针和边界指针。
- 自动释放池会有一个token令牌指向池边界，当池子执行了pop之后，所有非边界对象都会被release掉。此时这些对象都要比边界对象更热。边界对象并不会被release，它作为边界嘛。
- 栈在底层是双向链表结构的，这样可以快速的添加和删除对象。
- 线程本地存储指向热的页，该页面存储新自动释放的对象。
- 以双向链表的栈结构构成页
2.2 自动释放池的认识
2.2.1 查看源码
//***********push方法***********
void *
objc_autoreleasePoolPush(void)
{
return AutoreleasePoolPage::push();
}
//***********pop方法***********
void
objc_autoreleasePoolPop(void *ctxt)
{
AutoreleasePoolPage::pop(ctxt);
}
说明：
- 自动释放池的底层结构是AutoreleasePoolPage，是一个页结构
- 通过调用push和pop来管理池子，push创建池子，pop就是析构池子，当pop后就会将池子中所有的对象release掉
2.2.2 AutoreleasePoolPage
//************宏定义************
#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
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
AutoreleasePoolPage的大小是4096个字节
通过AutoreleasePoolPage()进行构造，其内部可以看到是通过AutoreleasePoolPageData()来构造的
和~AutoreleasePoolPage()进行析构
涉及API也可以简单看看，后续对池子的操作会用到
有关于页的操作，比如full()、hotPage()、autoreleaseNewPage(id obj)、push()、pop(void *token)
有关于对象的操作，比如add()、releaseAll()、autorelease(id obj)
2.2.3 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)
{
}
};
说明：
- 自动释放池有自己所在的线程
- 自动释放池是由多张页组成，这些页是以双向链表结构的形式存在，可以指向前一页和后一页
- depth可以当前页所在的位置，如果该页是第一页深度为0，如果是第二页，深度为1
- 并且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字节）
2.3 自动释放池的创建，也就是AutoreleasePoolPage的构造
2.3.1 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;
}
说明：
- 调用push构造池子，我们可以看到有两种情况来构造
- 第一种是slowpath，而且是debug状态下的，所以只看第二种autoreleaseFast方式，在创建池子的同时压入一个边界对象
2.3.2 autoreleaseFast()
源码：
//添加一个对象
static inline id *autoreleaseFast(id obj)
{
//获取当前页
AutoreleasePoolPage *page = hotPage();
//如果当前页存在，并且没有填满，就可以添加一个需要release的对象或者边界对象
if (page && !page->full()) {
return page->add(obj);
} else if (page) {//如果已满，就获取child页或者新建页
return autoreleaseFullPage(obj, page);
} else {//如果当前页不存在就说明当前池子就根本还没有页，就新建第一页
return autoreleaseNoPage(obj);
}
}
说明：
- 可以看到获取当前页有三种情况
- 如果当前页存在，而且可以存储没有填满，就直接add添加
- 如果当前页存在，但是已经满了，就需要通过autoreleaseFullPage()存储到其他页，如果所有页都满了就需要新建页
- 如果根本没有当前页，说明还不存在池子，就新建第一页autoreleaseNoPage()
2.3.3 add()
源码：
//开始位置
id * begin() {
//偏移页结构体的结构体本身大小的位置，说明就是入栈对象的初始位置
return (id *) ((uint8_t *)this+sizeof(*this));
}
//最后对象位置
id * end() {
//偏移页结构体的最大位置，也就是页的最后位置
return (id *) ((uint8_t *)this+SIZE);
}
//判断是否为空
bool empty() {
//如果当前对象位置是初始位置，说明是空的
return next == begin();
}
//判断是否已满
bool full() {
//next就是当前对象所指向的位置
//end()是每页最后的位置
return next == end();
}
//将对象obj赋给当前对象位置next，并将next++
id *add(id obj)
{
ASSERT(!full());
unprotect();
//1、先将next指向一个局部变量
id *ret = next; // faster than `return next-1` because of aliasing
//2、将obj指针赋给next
//3、给next++，也就是next以指针偏移的方式+1，这样很方便
*next++ = obj;
protect();
return ret;
}
说明：
- 都比较简单，而且注释也说的很清楚了
- 需要注意的一点就是next占有8个字节，可以存储一个对象的地址，它就表示将要插入的下一个对象的位置
- 因此我们可以直接将插入的对象赋给next就插入成功了，之后再次将next++到达下一次对象插入的位置
2.3.4 autoreleaseFullPage()
源码：
//获取下一个没有填充满的页，一直查询到最后一页如果仍然满就新建一页
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 {
//循环如果已经满了，就取下一页
if (page->child) page = page->child;
//如果没有child，也就是最后一页了，就新建一页
else page = new AutoreleasePoolPage(page);
} while (page->full());
//设置为当前页
setHotPage(page);
//压栈对象
return page->add(obj);
}
说明：
- 如果当前页已经充满了，就进入这个方法
- 有两个操作，循环判断下一页是否已满，如果未满就将这个页设置为当前页，并添加对象
- 如果已满，就继续找下一页，如果最后一页仍然满，就新建一页来添加对象
2.3.5 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;
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;
}
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;
}
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);
//第一页设置为当前页
setHotPage(page);
// Push a boundary on behalf of the previously-placeholder'd pool.
//既然创建的是第一页，就需要将边界对象压栈
if (pushExtraBoundary) {
page->add(POOL_BOUNDARY);
}
// Push the requested object or pool.
//再压栈一个待release的对象
return page->add(obj);
}
说明：
- 可以看到该方法是用来创建第一页的，并且第一页设置为当前页
- 如果是第一页就需要添加边界对象，之后再压栈一个待release的对象
- 新建页是通过构造函数AutoreleasePoolPage实现的
- 在分析自动释放池的认识时已经知道其实是通过其父类的AutoreleasePoolPageData的构造函数来实现的
2.3.5 总结
自动释放池的结构以及添加对象过程.png
- 自动释放池由多张页组成，这些页通过以双向链表的形式组织，并且这个页的数据结构是栈，遵循先进后出原则
- 构造自动释放池其实就是创建第一页，页的创建是通过AutoreleasePoolPage的构造函数来创建的
- 构造函数中会将结构体中的成员添加到页中，如果是第一页，还需要添加边界对象
- 如果只有一页，第一页就是当前页
- 在添加对象时需要先把前面的页填满，再依此添加到后面的页，如果所有的页都满了，就再继续创建页
- 页的创建都是通过AutoreleasePoolPage的构造函数来实现的，但是除了第一页，其他页都没有边界对象
- 创建的页越迟，处在池子的位置越深
大小的计算：
- 一页有多大：
- 根据AutoreleasePoolPage结构体中的定义可知是4096个字节
- 一页的结构体成员有多大：根据父类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字节
- 一页的边界对象有多大
- 所有的对象其实都是指针形式存储的，所以是8个字节
- 一页存储的release对象有多少
- 前面可以看到每页总共有4096个字节，减去结构体成员的56个字节，还剩4040个字节，一个对象占有8个字节，所以可以存储505个对象。
- 而第一页会占有一个边界对象，所以这么说：第一页可以添加504个对象，其他页可以添加505个对象
- depath如何计数：
- 每一页都有一个深度，表示该页在自动释放池中所处的位置。如果第一页表示没有深度，深度为0，如果是第二页深度为1
autorelease 底层分析
2.4 将对象添加到自动释放池的过程，也就是autorelease的过程
2.4.1 查看autorelease底层源码
代码：
__attribute__((aligned(16), flatten, noinline))
id
objc_autorelease(id obj)
{
//如果不是对象，则直接返回
if (!obj) return obj;
//如果是小对象，也直接返回
if (obj->isTaggedPointer()) return obj;
return obj->autorelease();
}
说明：
- 可以看到其实就是调用autorelease()实现的
2.4.2 autorelease()
主要是通过autoreleaseFast函数实现对象的添加
inline id
objc_object::autorelease()
{
ASSERT(!isTaggedPointer());
//判断是否是自定义类
if (fastpath(!ISA()->hasCustomRR())) {
return rootAutorelease();
}
return ((id(*)(objc_object *, SEL))objc_msgSend)(this, @selector(autorelease));
}
inline id
objc_object::rootAutorelease()
{
//如果是小对象，直接返回
if (isTaggedPointer()) return (id)this;
if (prepareOptimizedReturn(ReturnAtPlus1)) return (id)this;
return rootAutorelease2();
}
__attribute__((noinline,used))
id
objc_object::rootAutorelease2()
{
ASSERT(!isTaggedPointer());
return AutoreleasePoolPage::autorelease((id)this);
}
static inline id autorelease(id obj)
{
ASSERT(obj);
ASSERT(!obj->isTaggedPointer());//小对象类型不涉及
id *dest __unused = autoreleaseFast(obj);//其实也就是添加一个对象的过程
ASSERT(!dest || dest == EMPTY_POOL_PLACEHOLDER || *dest == obj);
return obj;
}
说明：
- 通过一步一步找，最终找到是在AutoreleasePoolPage结构体中的autorelease函数实现的
- 最终是调用autoreleaseFast添加对象，这个前面已经分析过了，这里就不再分析了。
2.4 自动释放池释放的过程，也就是pop的过程
2.4.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.
//如果当前页不存在，则清除空占位符
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(token, page, stop);
}
说明：
- 如果当前页不存在，说明池子中已经没有页了，池子已空。
- 通过popPage将页删除
2.4.2 popPage()
源码：
//删除一页
template
static void
popPage(void *token, AutoreleasePoolPage *page, id *stop)
{
if (allowDebug && PrintPoolHiwat) printHiwat();
//将该页的对象全部release
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
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();
}
}
}
说明：
- 删除页，需要先将页中存储的对象删除掉
- 如果该页为空，直接删除，并且设置上一页为当前页
- 如果该页已经是第一页了，就说明池子已空，就清空池子
- 如果仍然有下一页，就先把下一页删掉
2.4.3 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
//判断下一个对象是否等于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 empty
for (AutoreleasePoolPage *page = child; page; page = page->child) {
ASSERT(page->empty());
}
#endif
}
说明：
- 通过循环遍历，判断对象是否等于stop，其目的是释放stop之前的所有的对象
- 首先通过获取page的next释放对象（即page的最后一个对象），并对next进行递减，获取上一个对象
- 判断是否是哨兵对象，如果不是则自动调用objc_release释放
2.4.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;
//从后往前，将每一页都置位nil，也就是删掉每一页
do {
deathptr = page;
page = page->parent;
if (page) {
page->unprotect();
page->child = nil;
page->protect();
}
delete deathptr;
} while (deathptr != this);
}
说明：
- 这里就是删掉每一页，从后向前删除
- 删除的方式就是设置为nil。
2.4.5 总结
- 自动释放池的删除是对页的删除，从后向前一页一页的删除，后一页删除就将前一页设置为当前页，一直删除到没有当前页说明池子已空
- 页的删除主要是对象的release，也是从后向前一个一个的执行objc_release操作，一直到边界对象，release完成