美文网首页
19 - 内存管理方案之自动释放池AutoRelease

19 - 内存管理方案之自动释放池AutoRelease

作者: iOS之文一 | 来源:发表于2021-11-23 12:33 被阅读0次

    OC底层原理探索文档汇总

    自动释放池是OC中的一种自动垃圾回收机制。属于内存管理的一种方案。

    主要内容:

    1. 自动释放池的认识
    2. 自动释放池的本质
    3. 自动释放池的压栈和出栈过程分析

    1、自动释放池的认识

    1.1 介绍

    自动释放池是OC的一种自动垃圾回收机制,用来管理对象的释放。它可以将加入到autoreleasePool中的对象的release时机延迟。

    正常情况下,当一个对象停止指向某一个变量时,该对象会立即进行release。但是如果该对象加入到了自动释放池中,这个对象并不会立即release。而是会等到runloop休眠或者超出autoreleasePool作用域{}之后才会被释放。

    autoreleasePool的图示.png

    说明:

    1. 从程序启动到加载完成,主线程对应的runloop会处于休眠状态,等待用户交互来唤醒runloop。
    2. 用户的每一次交互都会唤醒一次runloop,用于处理用户的所有点击、触摸事件等。
    3. runloop在监听到交互事件后,就会创建自动释放池,并将所有延迟释放的对象添加到自动释放池中。
    4. 在一次完整的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完成

    相关文章

      网友评论

          本文标题:19 - 内存管理方案之自动释放池AutoRelease

          本文链接:https://www.haomeiwen.com/subject/ivvizltx.html