阅读 864

iOS 深入探究 AutoreleasePool

AutoreleasePool 是什么

AutoreleasePool (下面称为缓存池)是 iOS 开发中的一种内存管理的机制,对象调用 autorelease 方法后会被放到缓存池中延迟释放,当缓存池需要清除时,会向这些 Autoreleased 对象发送 release 消息。

新建一个 Xcode 项目,将项目调整成 MRC:

MRC 中,需要使用 retain/release/autorelease 手动管理内存,如下代码:

int main(int argc, const char * argv[]) {
    NSLog(@"-A-");
    Coder *coder = [[Coder alloc] init];
    [coder release];
    NSLog(@"-B-");
    return 0;
}

// log
-A-
Coder dealloc
-B-
复制代码

这里用 alloc 创建了 coder 对象,让它的引用计数增加,然后调用 release 方法完成释放。如果使用 autorelease,就需要用到自动缓存池了,代码如下:

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        NSLog(@"-A-");
        Coder *coder = [[[Coder alloc] init] autorelease];
        NSLog(@"-B-");
    }
    NSLog(@"-C-");
    return 0;
}

// log
-A-
-B-
Coder dealloc
-C-
复制代码

这里的 coder 对象在出了自动缓存池的作用域后被自动释放。

不是所有情况都是出了作用域后自动释放,后面详解。

@autoreleasepool 干了什么

通过 xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc main.m 命令将 main.m 转成 C++ 代码。

会发现 @autoreleasepool 被转成一个成员变量:

__AtAutoreleasePool __autoreleasepool; 
复制代码

__AtAutoreleasePool 结构体的实现:

struct __AtAutoreleasePool {
  __AtAutoreleasePool() {atautoreleasepoolobj = objc_autoreleasePoolPush();}
  ~__AtAutoreleasePool() {objc_autoreleasePoolPop(atautoreleasepoolobj);}
  void * atautoreleasepoolobj;
};
复制代码

这里有一个 C++ 的语法,__AtAutoreleasePool() 是构造函数,创建结构体时调用,~__AtAutoreleasePool() 是析构函数,在结构体销毁时调用,所以上面的代码就可以理解为:

int main(int argc, const char * argv[]) {
    void *atautoreleasepoolobj = objc_autoreleasePoolPush();
    // @autoreleasepool 括号里面的代码
    objc_autoreleasePoolPop(atautoreleasepoolobj);
    return 0;
}
复制代码

这也解释了上面说的为什么并不是所有情况都是出了 @autoreleasepool 作用域后自动释放,因为这只是一个语法糖,本质是调用了上面的 Push&PoP 方法。

AutoreleasePoolPage

runtime源码地址,这里使用的 objc4-723

在源码中查找上面的 Push&Pop 函数:

void *objc_autoreleasePoolPush(void)
{
    return AutoreleasePoolPage::push();
}

void objc_autoreleasePoolPop(void *ctxt)
{
    AutoreleasePoolPage::pop(ctxt);
}
复制代码

这里调用了 AutoreleasePoolPage 这个类的 Push&Pop 函数,关于 Push&Pop 这里先打住。先来看看 AutoreleasePoolPage 是怎样的结构,这里只有成员变量:

class AutoreleasePoolPage 
{
    magic_t const magic;
    id *next;
    pthread_t const thread;
    AutoreleasePoolPage * const parent;
    AutoreleasePoolPage *child;
    uint32_t const depth;
    uint32_t hiwat;
    // ...
}
复制代码

这里的 next 指针指向的是最新被添加进来的 autorelease 对象的下一个位置。 单看这个是不好理解的,所以这里直接先说 AutoreleasePoolPage

自动释放池实际上是封装的 AutoreleasePoolPage 这个 C++ 类,以双向链表的形式构成。每个 AutoreleasePoolPage 对象会开辟 4096 字节内存(也就是虚拟内存一页的大小),除了上面的实例变量所占空间,剩下的空间全部用来以栈的方式储存 autorelease 对象。AutoreleasePoolPage 空间被占满时,会以链表的形式新建链接一个 AutoreleasePoolPage 对象,然后将 autorelease 对象的地址存在里面。如图所示:

源码分析

回到最初的 C++ 代码:

void *atautoreleasepoolobj = objc_autoreleasePoolPush();
objc_autoreleasePoolPop(atautoreleasepoolobj);
复制代码

调用 Push 函数后,会获得一个返回值,这个返回值作为 Pop 函数的参数被传入了,下面来看看里面具体的原理是什么。直接来看 Push 函数的源码:

// 简化后
static inline void *push() 
{
    id *dest;
    dest = autoreleaseFast(POOL_BOUNDARY);
    return dest;
}
复制代码

这里有个 POOL_BOUNDARY 值得我们注意,不过查看它的定义会发现它其实是等价 nil 的宏定义:

#   define POOL_BOUNDARY nil
复制代码

也就是说,POOL_BOUNDARY 仅仅只是一个哨兵值。进入 autoreleaseFast(...) 函数:

static inline id *autoreleaseFast(id obj)
{
    AutoreleasePoolPage *page = hotPage();
    if (page && !page->full()) {
        // 1.
        return page->add(obj);
    } else if (page) {
        // 2.
        return autoreleaseFullPage(obj, page);
    } else {
        // 3.
        return autoreleaseNoPage(obj);
    }
}
复制代码

hotPage 指当前使用的 AutoreleasePoolPage 节点,coldPage 指已经被装满的链表节点。

这里的判断逻辑完全符合前面关于 AutoreleasePoolPage 的说明:

  • 1.当前 page 存在且没有满时,直接将对象添加到当前 page 中。
  • 2.当前 page 存在且已满时,创建一个新的 page ,并将对象添加到新创建的 page 中,然后将这两个链表节点链接。
  • 3.当前 page 不存在时,创建第一个 page ,并将对象添加到新创建的 page 中。

每次 Push 后,都会先添加一个 POOL_BOUNDARY 来占位,是为了对应一次 Pop 的释放,例如图中的 page 就需要两次 Pop 然后完全的释放。也就是代码中嵌套的情况:

@autoreleasepool {
    @autoreleasepool {

    }
}
复制代码

这里还需要强调的是,这里使用的是双链表来实现,只有在当前 page 空间使用完后,才会创建新的 page,并不是每个 @autoreleasepool 对应一个 AutoreleasePoolPage 对象。

接下来看 Pop 的源码:

// 简化后
static inline void pop(void *token) 
{   
    AutoreleasePoolPage *page;
    id *stop;
    page = pageForPointer(token);
    stop = (id *)token;
    // 1.根据 token,也就是上文的占位 POOL_BOUNDARY 释放 `autoreleased` 对象
    page->releaseUntil(stop);

// hysteresis: keep one empty child if page is more than half full
    // 2.释放 `Autoreleased` 对象后,销毁多余的 page。
    if (page->lessThanHalfFull()) {
        page->child->kill();
    }
    else if (page->child->child) {
        page->child->child->kill();
    }
}
复制代码

这里没什么说的,来到 releaseUntil(...) 内部:

// 简化后
void releaseUntil(id *stop) 
{
    // 1.
    while (this->next != stop) {
        AutoreleasePoolPage *page = hotPage();
        // 2.
        while (page->empty()) {
            page = page->parent;
            setHotPage(page);
        }
        // 3.
        if (obj != POOL_BOUNDARY) {
            objc_release(obj);
        }
    }
    // 4.
    setHotPage(this);
}
复制代码
  • 1.外部循环挨个遍历 autoreleased 对象,直到遍历到 stop 这个 POOL_BOUNDARY
  • 2.如果当前 hatPage 没有 POOL_BOUNDARY,将 hatPage 设置为父节点。
  • 3.给当前 autoreleased 对象发送 release 消息。
  • 4.再次配置 hatPage

再来看看 autorelease 的实现,这里直接定位到 page 里面的 autorelease:

// 简化后
static inline id autorelease(id obj)
{
    id *dest __unused = autoreleaseFast(obj);
    return obj;
}
复制代码

和上面的 push 操作中调用的同一函数 autoreleaseFast,没什么说的。

这里从源码层面上就了解了自动缓存池道理是怎么一回事。

AutoreleasePool 和 runloop

这里需要 runloop 的知识,可以看我前面的文章 iOS 浅谈 Runloop

App 启动后,苹果在主线程 RunLoop 里注册了两个 Observer,回调都是 _wrapRunLoopWithAutoreleasePoolHandler ,用来处理自动缓存池。

打印主线程的 runloop 进行确认。

print(RunLoop.main)
复制代码

注意观察图中 Observer 观察的状态,上面的是 activities = 0x1,下面的是 activities = 0xa0。这里需要一点 runloop 的知识,下面就是 runloop 可以被监听的状态枚举。

typedef CF_OPTIONS(CFOptionFlags, CFRunLoopActivity) {
    kCFRunLoopEntry = (1UL << 0),              // 1
    kCFRunLoopBeforeTimers = (1UL << 1),       // 2
    kCFRunLoopBeforeSources = (1UL << 2),      // 4
    kCFRunLoopBeforeWaiting = (1UL << 5),      // 32
    kCFRunLoopAfterWaiting = (1UL << 6),       // 64
    kCFRunLoopExit = (1UL << 7),               // 128
    kCFRunLoopAllActivities = 0x0FFFFFFFU
};
复制代码

0x1 (等于1)对应的是 kCFRunLoopEntry ,第一个 Observer 监视的即将进入Loop时,,其回调内会调用 _objc_autoreleasePoolPush() 创建一个自动释放池。其 order-2147483647,优先级最高,保证创建缓存池发生在其他所有回调之前。

0xa0(16进制等于160,等于32+128) 对应的是 kCFRunLoopBeforeWaiting&kCFRunLoopExit,第二个 Observer 监视了两个事件: 准备进入休眠时调用 _objc_autoreleasePoolPop()_objc_autoreleasePoolPush() 释放旧的池并创建新池;即将退出Loop时调用 _objc_autoreleasePoolPop() 来释放自动释放池。这个 Observerorder2147483647,优先级最低,保证其释放缓存池发生在其他所有回调之后。

所以对于我们应用来说,autoreleased 对象更多的是在 runloop 的休眠时进行释放的。

参考

关于 AutoreleasePool 还有一些实际使用中的技巧,例如解决循环中 autoreleased 对象的内存问题等等。

黑幕背后的Autorelease

Objective-C Autorelease Pool 的实现原理

关注下面的标签,发现更多相似文章
评论