自动释放池是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<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
-
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<false>(token, page, stop);
}
说明:
- 如果当前页不存在,说明池子中已经没有页了,池子已空。
- 通过popPage将页删除
2.4.2 popPage()
源码:
//删除一页
template<bool allowDebug>
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完成
网友评论