iOS最强面试iOS日常须知

浅谈AutoreleasePool底层是如何实现的?

2018-06-29  本文已影响6人  OnlyFunny

前一段时间总被问起AutoreleasePool相关问题, 今天呢自己总结一下, 把之前调研的关于AutoreleasePool的知识沉淀一下, 如有写的不对的地方大家能够帮忙指出,后续还会更新。

一、基本概念

ARC下的产物,为了替代人工管理内存,大大的简化了iOS开发人员的内存管理工作;实质上是使用编译器替代人工在适当的位置插入release、autorelease等内存释放操作;

二、底层结构

ARC时代下iOS程序员最常见的是main.m函数里的@autorelease{},这句话的含义

a. 查看@autorelease{}的C++实现

使用clang的rewrite-objc命令将main.m转换为main.cpp文件,可以到看其转换为C++的实现时的内容,从main.cpp中列出了比较重要几个地方:

1)@autoreleasepool实质上是一个__AtAutoreleasePool的结构体对象;
下面是main 函数的C++实现,声明了一个__AtAutoreleasePool对象,然后调用应用程序入口函数;

int main(int argc, char * argv[]) {
    /* @autoreleasepool */ {
        __AtAutoreleasePool __autoreleasepool;
        return UIApplicationMain(argc, argv, __null, NSStringFromClass(((Class (*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("AppDelegate"), sel_registerName("class"))));
    }
}

__AtAutoreleasePool的结构如下所示:

extern "C" __declspec(dllimport) void * objc_autoreleasePoolPush(void);
extern "C" __declspec(dllimport) void objc_autoreleasePoolPop(void *);

struct __AtAutoreleasePool {
  __AtAutoreleasePool() {atautoreleasepoolobj = objc_autoreleasePoolPush();}
  ~__AtAutoreleasePool() {objc_autoreleasePoolPop(atautoreleasepoolobj);}
  void * atautoreleasepoolobj;
};

可以看出来,当申明了一个对象__autoreleasepool,相当于调用了objc_autoreleasePoolPush()函数,该函数的作用即向堆栈内压入一个“自动释放池”;而当int main()函数执行完毕后,执行__autoreleasepool的析构函数objc_autoreleasePoolPop(atautoreleasepoolobj),用于释放“自动释放池”;所以main()函数里可以大致这样理解:

int main(int argc, char * argv[]) {
    /* @autoreleasepool */ {
        //创建自动释放池
        __AtAutoreleasePool __autoreleasepool = objc_autoreleasePoolPush();
        //TODO 执行各种操作,将对象加入自动释放池
        
        //释放自动释放池
        objc_autoreleasePoolPop(__autoreleasepool)
    }
}

b. AutoreleasePool的本质

已经有人在苹果的官方源码里找到了关于AutoreleasePool的底层实现NSObject.mm里,源码地址:https://opensource.apple.com/source/objc4/objc4-532/runtime/NSObject.mm.auto.html
objc_autoreleasePoolPush()objc_autoreleasePoolPop(__autoreleasepool)的实现如下:

void* objc_autoreleasePoolPush(void)
{
    if (UseGC) return NULL; //如果使用垃圾回收机制
    return AutoreleasePoolPage::push();
}

void objc_autoreleasePoolPop(void *ctxt)
{
    if (UseGC) return;

    // fixme rdar://9167170
    if (!ctxt) return;

    AutoreleasePoolPage::pop(ctxt);
}

从上面可以发现,C++AutoreleasePoolPage才是实际的实现所在,找到AutoreleasePoolPage:

class AutoreleasePoolPage 
{
#define POOL_SENTINEL 0
    static size_t const SIZE = 
#if PROTECT_AUTORELEASEPOOL
        4096;  // must be multiple of vm page size
#else
        4096;  // size and alignment, power of 2
#endif
    magic_t const magic; //用于数据校验
    id *next;            //栈顶地址
    pthread_t const thread; //所在的线程
    AutoreleasePoolPage * const parent; //父对象
    AutoreleasePoolPage *child; //子对象
    uint32_t const depth;   //page的序号?
    uint32_t hiwat;
    ...
}

去除了一些不重要的代码,可以看出这是一个典型的双向列表结构,每个Page大小为4096 Byte,所以AutoreleasePool实质上是一个双向AutoreleasePoolPage列表;接下来分析一下自动释放池的工作过程:

创建自动释放池

void* objc_autoreleasePoolPush()内部实际调用的是AutoreleasePoolPage::push()函数,其实现如下:

static inline void *push() 
    {
        if (!hotPage()) {
            setHotPage(new AutoreleasePoolPage(NULL));
        } 
        id *dest = autoreleaseFast(POOL_SENTINEL);
        assert(*dest == POOL_SENTINEL);
        return dest;
    }

hotPage()是找出当前的正在使用的page,第一次调用时hotPage为NULL,所以新建一个parent=NULLAutoreleasePoolPage对象作为自动释放池加入栈中,并将其设置为hotPage,然后返回POOL_SENTINEL的地址赋值给main()函数里的变量 __autoreleasepool;

然后将一个哨兵对象POOL_SENTINEL压入栈顶,即调用autoreleaseFast(POOL_SENTINEL)

static inline id *autoreleaseFast(id obj)
    {
        AutoreleasePoolPage *page = hotPage();
        if (page && !page->full()) {
            return page->add(obj);
        } else {
            return autoreleaseSlow(obj);
        }
    }

添加对象进自动释放池

可以看出,如果当前有page并且没有满,则直接将对象入栈顶(page->add(obj)):

id *add(id obj)
    {
        assert(!full());
        unprotect();
        *next++ = obj;
        protect();
        return next-1;
    }

将对象压入栈顶,然后将栈顶指针下移;
如果上述autoreleaseFast(id obj)中的page已经满了,则执行autoreleaseSlow(obj)

id *autoreleaseSlow(id obj)
    {
        AutoreleasePoolPage *page;
        page = hotPage();
        //如果没有page,则新建一个自动释放池,并添加obj对象进释放池
        if (!page) {
            objc_autoreleaseNoPool(obj);
            return NULL;
        }
        //如果当前hotPage已经满了,则以链表的形式新增一个page并添加到当前page的后面,然后将此设置为hotPage;
        do {
            if (page->child) page = page->child;
            else page = new AutoreleasePoolPage(page);
        } while (page->full());

        setHotPage(page);
        return page->add(obj);
    }

基本逻辑即,如果page不存在则,创建新的自动释放池(PoolPage),并将对象加进池子;如果已经存在自动释放池在栈中,且hotPage满了,则遍历其子page,如果存在没满(page->full()==NO)的子page,则将该子page设置为hotPage,否则如果都满了,则以最后一个子page为父page,新建一个page,插入当前的page链表,同样设置该新建的pagehotPage,然后将自动释放对象加入page

销毁自动释放池

销毁自动释放池的调用方式是:

void AutoreleasePoolPage::pop(void *token)

tokenpush()的返回值,实际上就是POOL_SENTINEL的地址(__autoreleasepool)通过该地址即可找到所在Page的地址指针

static inline void pop(void *token) 
    {
        AutoreleasePoolPage *page;
        id *stop;

        if (token) {
            page = pageForPointer(token); //找到所在的page地址
            stop = (id *)token; //POOL_SENTINEL的地址,从栈顶释放对象直到这个位置
        } else {
            // Token 0 is top-level pool
            page = coldPage();
            stop = page->begin();
        }

        page->releaseUntil(stop); //对自动释放池中对象调用objc_release()进行释放

        // memory: delete empty children
        // hysteresis: keep one empty child if this page is more than half full
        // special case: delete everything for pop(0)
        if (!token) {
            page->kill();
            setHotPage(NULL);
        } else if (page->child) {
            if (page->lessThanHalfFull()) {
                page->child->kill();
            }
            else if (page->child->child) {
                page->child->child->kill();
            }
        }
    }
该过程主要分为两步:

一、page->releaseUntil(stop),对栈顶(page->next)stop地址(POOL_SENTINEL)之间的所有对象调用objc_release(),进行引用计数减1;

二、清空page对象page->kill(),有两句注释

// hysteresis: keep one empty child if this page is more than half full
// special case: delete everything for pop(0)

除非是pop(0)方式调用,这样会清理掉所有page对象;否则,在当前page存放的对象大于一半时,会保留一个空的子page,这样估计是为了可能马上需要新建page节省创建page的开销吧.

对应代码

if (page->child) {
           if (page->lessThanHalfFull()) {
               page->child->kill(); //全部删除
           }
           else if (page->child->child) {
               page->child->child->kill();//保留一个子page
           }
       }

如果当前的page中存放的对象少于一半,则子page全部删除;如果当前当前的page存放的多余一半(意味着马上将要满),则保留一个子page,节省创建新page的开销;

上一篇下一篇

猜你喜欢

热点阅读