028＊：NSAutoReleasePool（objc_autoreleasePoolPush、objc_autoreleasePoolPop）AutoreleasePoolPageData（56） 哨兵元素 autoreleaseFast（autoreleaseNoPage、autoreleaseNewPage、autoreleaseFullPage）

问题

1：每个线程创建的时候就会创建一个autorelease pool，并且在线程退出的时候，清空autorelease pool。所以子线程的autorelease对象，要么在子线程中设置runloop清楚

2：AutoreleasePoolPage

面试题1：临时变量什么时候释放？
面试题2：简述自动释放池原理
面试题3：自动释放池能否嵌套使用？可以嵌套，添加哨兵。

NSAutoreleasePool的使用场景：

3：什么时候使用@autoreleasepool ？

  1. 写基于命令的程序时，就是没有UIKit框架，例如appkit、cocoa框架时。
  2. 写循环，循环里包含大量的临时变量创建时。
  3. 创建新的线程任务。（非cocoa程序创建时才需要）
  4. 长期在后台运行的任务。

根据Apple文档的建议，如果在一个循环中产生了大量的临时对象，可以通过在循环内部提供一个自动释放池在下一次迭代之前来清除这些对象，以减少最大内存占用。

// 测试的次数
size_t count = 10;

// 循环中产生的实例的个数
NSUInteger objectCount = 10000000;

// 测试2 - @autoreleasepool在循环内部
// 在循环中产生的之后不再被使用的实例将代码执行到@autoreleasepool代码块的第二个括号时被调用release操作
// 实际测试中，内存占用的峰值为16M，平均耗时为9902072437纳秒
uint64_t time2 = dispatch_benchmark(count, ^{
    for (NSUInteger i = 0; i < objectCount; ++i) {
        @autoreleasepool {
            [NSString stringWithFormat:@"str - %lu", (unsigned long)i];
        }
    }
});
NSLog(@"for { @autoreleasepool { } } = %llu ns", time2);

4：自动释放池什么时候释放？什么时候创建

 

1、一个观察者监测RunLoop的kCFRunLoopEntry状态（最高优先级order = -2147483647，由于优先级最高，因此先于所有其他回调操作生成）。
设置这个观察者的目的在于在RunLoop启动刚进入的时候生成自动释放池。

 

2、另一个观察者监测RunLoop的kCFRunLoopBeforeWaiting状态和kCFRunLoopExit状态（最低优先级order = 2147483647）。
该观察者的任务是当RunLoop在即将休眠时，调用_objc_autoreleasePoolPop（）销毁自动释放池，根据池中的记录，向池中所有对象发送realse方法真正地减少其引用计数，并调用_objc_autoreleasePoolPush（）创建新的自动释放池，当RunLoop即将退出的时候调用_objc_autoreleasePoolPop（）销毁池子。

 

而主线程中执行的代码，通常都是写在RunLoop事件回调，Timer回调中，处于自动释放池范围内，因此不会出现内存泄漏，开发人员也不需要显示在主线程创建自动释放池了。

 

oc中的自动释放池本质上就是延迟释放，将向自动释放池中对象发送的释放消息存在pool中，当pool即将被销毁的时候向其中所有对象发送realse消息使其计数减小。
而自动释放池的创建和销毁也是由RunLoop控制的。

 

结论：
自动释放池什么时候释放？通过Observer监听RunLoop的状态，一旦即将进入睡眠或者退出状态，则会销毁自动释放池，然后向池中对象发送release方法，减少引用计数。

 

目录

1：autorelease自动释放池

2：objc_autoreleasePoolPush

3：objc_autoreleasePoolPop

预备

 

正文

一：autorelease自动释放池

autorelease自动释放池： 自动管理作用域内对象引用计数的池子。

1 ：Clang分析

1：APP的入口函数main，包含了@autoreleasepool:

int main(int argc, const char * argv[]) {
    @autoreleasepool {
    }
    return 0;
}

2：通过clang编译成底层实现，命令为：xcrun -sdk iphonesimulator clang -arch x86_64 -rewrite-objc main.m

struct __AtAutoreleasePool {
    //构造函数
    __AtAutoreleasePool() {
            atautoreleasepoolobj = objc_autoreleasePoolPush();
    }
    //析构函数
    ~__AtAutoreleasePool() {
            objc_autoreleasePoolPop(atautoreleasepoolobj);
     }
      void * atautoreleasepoolobj;
};

int main(int argc, const char * argv[]) {
   { 
        //是一个结构体
         __AtAutoreleasePool __autoreleasepool; 
    }
    return 0;
}

简单来说，自动释放池其本质也是一个对象

总结

  • autoreleasepool其本质是一个结构体对象，一个自动释放池对象就是页，是是栈结构存储，符合先进后出的原则即可

  • 页的栈底是一个56字节大小的空占位符，一页总大小为4096字节。页是一个双向链表（表示有父节点 和 子节点，在类中提及过，即类的继承链）

  • 只有第一页有哨兵对象，最多存储504个对象，从第二页开始最多存储505个对象

  • autoreleasepool在加入要释放的对象时，底层调用的是objc_autoreleasePoolPush方法

  • autoreleasepool在调用析构函数释放时，内部的实现是调用objc_autoreleasePoolPop方法

对于自动释放池，我们主要关心的点有以下三点：

  • 1、自动释放池什么时候创建？

  • 2、对象是如何加入自动释放池的？

  • 3、哪些对象才会加入自动释放池？

2：AutoreleasePoolPage

  • 从最初的clang或者汇编分析我们了解了自动释放池其底层是调用的objc_autoreleasePoolPush和objc_autoreleasePoolPop两个方法，其源码实现如下
//***********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的定义，
4：AutoreleasePoolPageData

发现其中有AutoreleasePoolPage对象，所以有以下一个关系链AutoreleasePoolPage -> AutoreleasePoolPageData -> AutoreleasePoolPage，从这里可以说明自动释放池除了是一个页，还是一个双向链表结构

其中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 源码分析

进入push源码实现，有以下逻辑

  • 判断是否为有 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)
    {
    }

其中AutoreleasePoolPageData方法传入的参数含义为：

  • begin()表示压栈的位置（即下一个要释放对象的压栈地址）。可以通过源码调试begin，发现其具体实现等于页首地址+56，其中的56就是结构体AutoreleasePoolPageData的内存大小
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 方法
//添加自动释放对象，当页满的时候调用这个方法
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指向新建页面，由此可以得出页是通过双向链表连接

//********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

面试题：哨兵在一个自动释放池有几个？

  • 只有一个哨兵对象，且哨兵在第一页

  • 第一页最多可以存504个对象，第二页开始最多存 505个

2、压栈对象 autoreleaseFast

  • 进入autoreleaseFast源码，主要有以下几步：

    • 获取当前操作页，并判断页是否存在以及是否满了

    • 如果页存在，且未满，则通过add方法压栈对象

    • 如果页存在，且满了，则通过autoreleaseFullPage方法安排新的页面

    • 如果页不存在，则通过autoreleaseNoPage方法创建新页

从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;
}

3、autorelease 底层分析

在demo中，我们通过autorelease方法，在MRC模式下，将对象压栈到自动释放池，下面来分析其底层实现

  • 查看autorelease方法源码
    • 如果不是对象 或者 是小对象，则直接返回
    • 如果是对象，则调用对象的autorelease进行释放
__attribute__((aligned(16), flatten, noinline))
id
objc_autorelease(id obj)
{
    //如果不是对象，则直接返回
    if (!obj) return obj;
    //如果是小对象，也直接返回
    if (obj->isTaggedPointer()) return obj;
    return obj->autorelease();
}
  • 进入对象的autorelease实现
👇
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());
    //autoreleaseFast 压栈操作
    id *dest __unused = autoreleaseFast(obj);
    ASSERT(!dest  ||  dest == EMPTY_POOL_PLACEHOLDER  ||  *dest == obj);
    return obj;
}

从这里看出，无论是压栈哨兵对象，还是普通对象，都会来到autoreleaseFast方法，只是区别标识不同而以

三：objc_autoreleasePoolPop 源码分析

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

  • 进入pop源码实现，主要由以下几步

    • 空页面的处理，并根据token获取page

    • 容错处理

    • 通过popPage出栈页

//出栈
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);
    }
    //出栈页autoreleaseFast
    return popPage<false>(token, page, stop);
}
  • 进入popPage源码，其中传入的allowDebug为false，则通过releaseUntil出栈当前页stop位置之前的所有对象，即向栈中的对象发送release消息，直到遇到传入的哨兵对象
//出栈页面
template<bool allowDebug>
    static void
    popPage(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 empty
    for (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 garbage
    AutoreleasePoolPage *page = this;
    //获取最后一个页
    while (page->child) page = page->child;

    AutoreleasePoolPage *deathptr;
    do {
        deathptr = page;
        //子节点 变成 父节点
        page = page->parent;
        if (page) {
            page->unprotect();
            //子节点为nil
            page->child = nil;
            page->protect();
        }
        delete deathptr;
    } while (deathptr != this);
}

 

总结

通过上面的分析，针对自动释放池的push和pop，总结如下

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

所以，综上所述，autorelease和objc_autoreleasePush的整体底层的流程如下图所示

自动释放池的出栈（即pop）操作中
  • 在页中出栈普通对象主要是通过next指针递减进行的，
  • 当页空了时，需要赋值页的parent对象为当前页

  • autoRelease的嵌套，并没有在结构上进行嵌套。而是利用哨兵的作用，直接多插入一个哨兵。
  • 因为每次遇到哨兵(pop出栈时)，都表示一个autorelease可释放

注意 

  • autoRelease的嵌套，并没有在结构上进行嵌套。而是利用哨兵的作用，直接多插入一个哨兵。
  • 因为每次遇到哨兵(pop出栈时)，都表示一个autorelease可释放 

引用

1：iOS-底层原理 33：内存管理（三）AutoReleasePool & NSRunLoop 底层分析

2：OC底层原理三十七：内存管理（autorelease & runloop）

3：iOS 底层原理 - 自动释放池

posted on 2020-12-04 20:18  风zk  阅读(139)  评论(0)  编辑  收藏  举报

导航