专栏首页iOS技术iOS 底层拾遗:AutoreleasePool

iOS 底层拾遗:AutoreleasePool

前言

在阳神的 黑幕背后的Autorelease 文章中已经把 AutoreleasePool 核心逻辑讲明白了,不过多是结论性的东西,笔者通读源码以探究更多的细节,验证一下老生常谈的一些结论。

源码基于 Runtime 750。

一、@autoreleasepool {} 干了些什么

main.m 文件代码:

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

使用 clang -rewrite-objc main.m 查看经过编译器前端处理的代码:

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

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

可以看出@autoreleasepool{}会创建一个__AtAutoreleasePool类型的局部变量并包含在当前作用域,__AtAutoreleasePool构造和析构时分别调用了两个方法,所以简化过程如下:

void *context = objc_autoreleasePoolPush()
// 对象调用 autorelease 装入自动释放池
objc_autoreleasePoolPop(context)

可以猜测 push 和 pop 操作是实现自动释放的关键。

二、AutoreleasePoolPage 内存分布

官方文档 中提到了,主线程以及非显式创建的线程(比如 GCD)都会有一个 event loop (RunLoop 就是具体实现),在 loop 的每一个循环周期的开始和结束会分别调用自动释放池的 push 和 pop 方法,由此来实现自动的内存管理。由此也可以确定,自动释放池是与线程一一对应的。

objc_autoreleasePoolPush()objc_autoreleasePoolPop(...)实际上会调用到AutoreleasePoolPage类的push()pop()方法,先看一下这个类的数据结构:

class AutoreleasePoolPage {
    ...
    magic_t const magic;
    id *next;
    pthread_t const thread;
    AutoreleasePoolPage * const parent;
    AutoreleasePoolPage *child;

    static void * operator new(size_t size) {
        return malloc_zone_memalign(malloc_default_zone(), SIZE, SIZE);
    }
    id * begin() {
        return (id *) ((uint8_t *)this+sizeof(*this));
    }
    id * end() {
        return (id *) ((uint8_t *)this+SIZE);
    } 
    ...
}
  • parentchild正是指向前驱和后继指针,自动释放池就是一个以AutoreleasePoolPage为节点的双向链表(后文验证)。
  • thread是指当前 page 所对应的线程。
  • magic用于校验内存是否损坏。
  • next指向当前可插入对象的地址。

内存对齐

重写了new运算符,使用了malloc_zone_memalign(...)进行内存分配:

extern void *malloc_zone_memalign(malloc_zone_t *zone, size_t alignment, size_t size) ;
    /* 
     * Allocates a new pointer of size size whose address is an exact multiple of alignment.
     * alignment must be a power of two and at least as large as sizeof(void *).
     * zone must be non-NULL.
     */

注释说得很清楚了,这个方法以alignment对齐的地址分配size的内存空间。调用时两个参数都使用了SIZE宏,实际上就是虚拟内存页的大小:

#define I386_PGBYTES            4096

一个 page 的内存空间设置过小会导致更多的开辟空间操作降低效率,大量的parent/child指针变量也会占用可观的内存;空间设置过大可能会导致一个 page 的利用率低浪费过多内存。设置为 4096 是比较考究的,在保证内存对齐的情况下最大化利用空间避免内存碎片。这么做过后 page 的地址总是 4096 的整数倍,可以让某些运算更便捷(比如后文会说的通过指针地址寻找对应的 page)。

begin() 与 end()

AutoreleasePoolPage本身的大小远不及 4096,而超出的空间正是用来存放“期望被自动管理的对象”。begin()end()方法标记了这个范围。

sizeof(*this)表示AutoreleasePoolPage本身的大小,那么(uint8_t *)this+sizeof(*this)就是最低地址,(uint8_t *)this+SIZE就是最高地址。逐个插入对象时,next指针从begin()end()逐个移动,后面的full()方法就是指next == end()empty()就是指next == begin()

值得注意的是next/end()/begin()等都是id *类型的,即指向指针的指针,进行 +1 -1 运算时移动的是一个id大小的距离。

三、push 逻辑

push()方法会调用autoreleaseFast(POOL_BOUNDARY)

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

hotPage 指的是当前可插入对象的 page,放到后面一点分析,先来看插入对象的逻辑,分三种情况:

1、当 page 存在且没满时,直接添加对象:

    id *add(id obj)
    {
        assert(!full());
        unprotect();
        id *ret = next;  // faster than `return next-1` because of aliasing
        *next++ = obj;
        protect();
        return ret;
    }

unprotect()/protect()内部使用了int mprotect(void *a, size_t b, int c),设置内存起点a长度b的内存区域为c类型的访问限制:

    inline void protect() {
#if PROTECT_AUTORELEASEPOOL
        mprotect(this, SIZE, PROT_READ);
        check();
#endif
    }
    inline void unprotect() {
#if PROTECT_AUTORELEASEPOOL
        check();
        mprotect(this, SIZE, PROT_READ | PROT_WRITE);
#endif
    }

unprotect()设置为可读可写,protect()设置为只读,所以这里的目的是保证 page 写安全。不过有#define PROTECT_AUTORELEASEPOOL 0定义说明目前版本还没有开放这个保护功能。

2、当 page 存在且满了时,拓展 page 节点并添加对象:

    static __attribute__((noinline))
    id *autoreleaseFullPage(id obj, AutoreleasePoolPage *page)
    {   ...
        do {
            if (page->child) page = page->child;
            else page = new AutoreleasePoolPage(page);
        } while (page->full());

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

循环的逻辑:从 child 方向找到未满的 page,若找不到则创建一个新 page 拼接到链表尾部(AutoreleasePoolPage 构造方法会把传入的 page 参数作为 parent 前驱对象)。后面再设置最新的 page 为 hotpage 并将 obj 添加进 page。

3、当 page 不存在时,初始化一个

    static __attribute__((noinline))
    id *autoreleaseNoPage(id obj) 
    {   ...
        AutoreleasePoolPage *page = new AutoreleasePoolPage(nil);
        setHotPage(page);
        ...
        return page->add(obj);
    }

这个方法核心就是创建第一个 page 然后加入线程局部存储。

hotPage

从上面的push()方法分析可知,被自动管理的对象会不断插入双向链表从前到后第一个未满 page ,hotPage()其实就是指向这个 page,还有个coldPage()方法是根据hotPage()找到第一个 page。

既然自动释放池是由AutoreleasePoolPage组成的双向链表,那这个链表该如何访问呢?可能常规的思路是创建一个全局变量来访问它,不过这里使用了另外一个方式:

    static inline AutoreleasePoolPage *hotPage() 
    {
        AutoreleasePoolPage *result = (AutoreleasePoolPage *)
            tls_get_direct(key);
        // EMPTY_POOL_PLACEHOLDER 表示没有 page
        if ((id *)result == EMPTY_POOL_PLACEHOLDER) return nil;
        if (result) result->fastcheck();
        return result;
    }
    static inline void setHotPage(AutoreleasePoolPage *page) 
    {
        if (page) page->fastcheck();
        tls_set_direct(key, (void *)page);
    }

tls_get_direct(...)tls_set_direct(...)内部就是使用线程的局部存储(TLS: Thread Local Storage)将 page 存储起来,这样可以避免维护额外的空间来记录尾部的 page。由此也验证了自动释放池与线程一一对应的关系。

在 YYKit 中有一个使用广泛的技巧:将某个对象最后使用时放在异步线程,如果这个对象释放就(可能?)会在这个异步线程,从而降低主线程压力。实际上就是编译器插入 autorelease 代码将对象加入到异步线程的自动释放池,而如果异步线程的释放池先于主线程的释放池pop()而调用对象的release()方法,那么这个对象如果释放就会在异步线程。所以笔者认为这个优化并非绝对有效(这里衍生出一个问题:一个对象被多个自动释放池管理,若对象释放这些释放池怎么避免的野指针问题?)。

POOL_BOUNDARY

push()方法调用autoreleaseFast(POOL_BOUNDARY)时传入的是一个 POOL_BOUNDARY 并非需要被管理的对象,它的定义如下:

#   define POOL_BOUNDARY nil

在调用autoreleaseFast(obj)方法会返回指向obj指针的指针,它是一个id *类型,也就是说,这个返回值关心的只是obj指针的地址,而不是obj值的地址,obj指针的地址就是对应AutoreleasePoolPage对象内存中的某段区域。

再看一下上层调用:

void *context = objc_autoreleasePoolPush()
...
objc_autoreleasePoolPop(context)

pop 时会将这个obj指针的地址传入进去。pop 的逻辑是把 hotPage 到其 parent 前驱节点里面装的对象依次移除并发送 release 消息(后面会详细分析),而移除对象操作何时停止就是靠这个obj指针的地址。

所以,push 操作加入一个 POOL_BOUNDARY 实际上就是加一个边界,pop 操作时根据边界判断范围,这就是一个入栈与出栈的过程。

magic 校验

多次出现的check()方法如下:

    void check(bool die = true)  {
        if (!magic.check() || !pthread_equal(thread, pthread_self())) busted(die);
    }
    void fastcheck(bool die = true)  {
//补充:#define CHECK_AUTORELEASEPOOL (DEBUG)
#if CHECK_AUTORELEASEPOOL
        check(die);
#else
        if (! magic.fastcheck()) busted(die);
#endif
    }

可以看到,它们都调用了magic的 check 方法,在 DEBUG 时还会去检查当前线程是否与 page 的线程一致。

magicmagic_t类型的,这个结构体主要是有个uint32_t m[4];数组,构造时内存直接会写为0xA1A1A1A1 AUTORELEASE!,然后check()逻辑就是判断构造时的值是否发生了改变,若发生改变说明这个 page 已经被破坏。

四、autorelease 逻辑

上层对象调用 autorelease 方法会调用到AutoreleasePoolPage的以下方法:

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

显然,最终还是会调用前面解析的autoreleaseFast(...)方法进行对象插入。由此也可以推断,在一个 Thread 没有 Runloop 自动执行自动释放池的 push 和 pop 时,对象进行 autorelease 时若发现没有自动释放池节点会自动创建 page 并加入线程局部存储(参考前面的autoreleaseNoPage(...)方法分析)。

五、pop 逻辑

objc_autoreleasePoolPop(context)context参数是objc_autoreleasePoolPush()返回的,实际上就是POOL_BOUNDARY对应的在AutoreleasePoolPage中的地址。最终会调用到pop()方法:

    static inline void pop(void *token) 
    {
        AutoreleasePoolPage *page;
        id *stop;
        ...
        // 拿到 token 边界对应的 page
        page = pageForPointer(token);
        stop = (id *)token;
        ...
        // pop 内部对象直到 stop 边界
        page->releaseUntil(stop);
        ...
        // 删除空的 child 链表节点,如果当前页对象超过一半,保留下一个空节点
        if (page->lessThanHalfFull()) {
            page->child->kill();
        }
        else if (page->child->child) {
            page->child->child->kill();
        }
    }

pop()的逻辑应该很好理解了,token参数就是边界,下面分别分析步骤:

找到边界对应的 page

    static AutoreleasePoolPage *pageForPointer(const void *p) {
        return pageForPointer((uintptr_t)p);
    }
    static AutoreleasePoolPage *pageForPointer(uintptr_t p) {
        AutoreleasePoolPage *result;
        uintptr_t offset = p % SIZE;
        ....
        result = (AutoreleasePoolPage *)(p - offset);
        result->fastcheck();
        return result;
    }

onst void *p是指针的指针,((uintptr_t)p)才表示POOL_BOUNDARY指针在对应 page 中的地址。

前面分析过内存对齐的处理,那么uintptr_t p的值必然是 SIZE (4096) 的倍数,那么p % SIZE就得到了这个p在 page 中的地址偏移,最后通过p - offset就拿到了 page 的起始地址,这个处理比较秀。

移除被管理对象并发送 release 消息

    void releaseUntil(id *stop)  {
        while (this->next != stop) {
            AutoreleasePoolPage *page = hotPage();
            // 如果当前 page 空了,指向 parent
            while (page->empty()) {
                page = page->parent;
                setHotPage(page);
            }
            // 将即将要移除对象对应 page 中的内存置为 SCRIBBLE
            page->unprotect();
            id obj = *--page->next;
            memset((void*)page->next, SCRIBBLE, sizeof(*page->next));
            page->protect();
            // 调用对象的 release 方法
            if (obj != POOL_BOUNDARY) {
                objc_release(obj);
            }
        }
        // 把当前 page 设置 hotpage(调用时 this 就是对应期望释放边界的 page)
        setHotPage(this);
        ...
    }

清除 child

    void kill() {
        AutoreleasePoolPage *page = this;
        while (page->child) page = page->child;
        AutoreleasePoolPage *deathptr;
        do {
            deathptr = page;
            page = page->parent;
            if (page) {
                page->unprotect();
                page->child = nil;
                page->protect();
            }
            delete deathptr;
        } while (deathptr != this);
    }

这个逻辑一目了然了。

后语

以上就是自动释放池大部分源码的分析了,这部分源码没有涉及汇编并且代码量比较少,所以看起来相对容易。多理解一些内存管理底层有利于理解各种上层特性、定位内存难题,也有助于写出更稳定的代码。并且在这个过程中,不可避免需要接触操作系统和编译原理相关知识,也算是能培养通识性能力。

读源码远比记结论重要,遇到某些优秀的代码细节往往令人惊喜,不失为一种乐趣。

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • OCMock 源码分析

    单元测试作为日常工作中不可或缺的部分,虽然增加了需求开发的工作量,但能在一定程度上提高代码的稳定性。特别是迭代时通常能更快更准确的验证以往的算法或边界是否异常,...

    波儿菜
  • YBImageBrowser 重构心得:如何优化架构、性能、内存?

    界面展示类型的轮子往往定制性需求比较多,常常让人抓耳挠腮。这种接近业务的轮子如何设计才能兼顾便捷性和拓展性?如何有效的优化性能?如何控制内存不至于 OOM ?本...

    波儿菜
  • 打造开源第一 iOS 图片浏览器 (支持视频)闲谈

    本文主要讲述 YBImageBrowser 的一些功能技术细节,代码架构思路,设计模式选择等,希望对组件原理感兴趣的朋友有所帮助,也可以作为如何高效构建图片浏览...

    波儿菜
  • optimize 回收表空间的一些说明

    线上服务器,有张大表需要用pt-archiver根据时间划分归档大量数据到另一个新表中。原先200G的表,在归档完成后,du -hs 显示依然是200G的大小,...

    二狗不要跑
  • [linux][memory]KSM技术分析

    前言: 先来回顾一下Linux平台上的节约内存的方案: swap:通过LRU淘汰掉掉一部分page,把这些page交换到磁盘上。再次访问到这些page的时候,k...

    皮振伟
  • Django自定义分页

    py3study
  • CRM之分页

      分页功能在网页中是非常常见的一个功能,其作用也就是将数据分割成多个页面来进行显示。

    py3study
  • django 分页

    https://www.jianshu.com/p/77a8ea421e22 https://blog.csdn.net/weixin_42134789/ar...

    以谁为师
  • 26.Django模板语言和分页

    继承 extends  子版只能继承一个父模板 1.父模板 master.html <!DOCTYPE html> <html lang="en"> <head...

    zhang_derek
  • 13.Django基础之django分页

      我们使用脚本批量创建一些测试数据(将下面的代码保存到bulk_create.py文件中放到Django项目的根目录,直接执行即可。):

    changxin7

扫码关注云+社区

领取腾讯云代金券