Autorelease Pool的底层实现和相关事项总结

作者: 问问你是谁 | 来源:发表于2020-10-22 23:16 被阅读0次

重新仔细读了下源码，通过留些笔记的方式加深理解。由于我的C++水平有限，可能有些地方理解的不到位，甚至有错误，希望有朋友帮我指正。

一、@autoreleasepool {}是什么？
创建个新工程，简单起见，把main.m改成这样：

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

打开终端，cd到main.m的目录下，用命令“clang -rewrite-objc main.m”，看看C++的实现。报错的话，根据错误信息修改。打开同目录下新生成的main.cpp，搜索找到main函数的实现，如下：

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

初步可见，@autoreleasepool{}是通过__AtAutoreleasePool类型的局部变量__autoreleasepool来实现的。再搜索下，会发现__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{
    NSString *str = [NSString stringWithFormat:@"Hello, World! "];
}

// 实际就相当于：
/* @autoreleasepool */ { 
    atautoreleasepoolobj = objc_autoreleasePoolPush();

    // 暂先不用理会这行代码c++的实现是什么样子
    NSString *str = [NSString stringWithFormat:@"Hello, World! "];

    objc_autoreleasePoolPop(atautoreleasepoolobj);
}

接下来的任务是看objc_autoreleasePoolPush()和objc_autoreleasePoolPop()做了什么。显然要看runtime的源码。

二、Autorelease Pool的数据结构
在继续看源码之前，我想先根据我个人的理解说明下autorelease pool的数据结构（如果理解有误，希望有同学指正），带着这个总体概念有助于继续阅读源码。

首先，每个线程都可以有自己的autorelease pool，系统会默认为主线程创建一个，而子线程默认是没有的。这点后面会再进一步说明。

然后，线程可以有0到多个pool，1到多个pool形成一个栈，栈中存储需要autorelease的对象指针或者名叫POOL_BOUNDARY的占位符（用来区隔不同的pool）。这个栈又由不同的page组成，每个page有固定的size，还有parent和child两根指针。多个page之间通过指针相连，这样就形成了一种类似链栈的结构。

三、runtime源码中的实现
runtime源码（这里用objc4-781）里很容找到一中提到的两个函数的实现：

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

继续向下找AutoreleasePoolPage。

AutoreleasePoolPage
首先我们会找到下面的代码和注释：

/***********************************************************************
   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.
   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.
   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. 
**********************************************************************/
class AutoreleasePoolPage : private AutoreleasePoolPageData

可以结合二中提到的内容看看这些注释：
// 一个线程的autorelease pool是一个指针栈。
// 栈中存放的指针指向需要release的对象或者POOL_BOUNDARY（作用如二中所提）。
// 每个pool会有一个token指针，指向pool的POOL_BOUNDARY（哨兵）。当这个pool执行出栈操作时，每一个比这个哨兵后入栈的对象都会被released。
// 这个栈是由一个以pages为节点的双向链表组成，pages会根据需求进行增减。
// 线程局部变量（Thread-local storage / tls）存储了指向最新page（the hot page）的指针，最近被autoreleased的对象会被存储在这个page里。

AutoreleasePoolPageData
这里我们可以看到上面所谓双向链表的节点的结构：

class AutoreleasePoolPage;
struct AutoreleasePoolPageData
{
    magic_t const magic;  // 用于结构的完整性校验
    __unsafe_unretained id *next;  // 当前page的栈顶指针
    pthread_t const thread;  // 所属线程
    AutoreleasePoolPage * const parent;  // 父节点
    AutoreleasePoolPage *child;  // 子节点
    uint32_t const depth;  // 链表结点数
    uint32_t hiwat;  // 当前链表储存指针的个数？

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

节点结构清楚了，来看看push操作。

AutoreleasePoolPage::push()
直接看源码加注释：

static inline void *push() 
{
    id *dest;
    if (slowpath(DebugPoolAllocation)) {
        // debug模式下，每一个autorelease pool都从一个新的page开始。
        // 注意这里操作的对象是：POOL_BOUNDARY
        dest = autoreleaseNewPage(POOL_BOUNDARY);
    } else {
        dest = autoreleaseFast(POOL_BOUNDARY);
    }
    ASSERT(dest == EMPTY_POOL_PLACEHOLDER || *dest == POOL_BOUNDARY);
    // 返回POOL_BOUNDARY存入的位置
    return dest;
}

static inline id *autoreleaseFast(id obj)
{
    // hotPage可以理解为当前工作的page，也就是最近被autoreleased的对象指针会被加入的page，下同
    AutoreleasePoolPage *page = hotPage();
    if (page && !page->full()) {
        // 如果hotPage没满，存入obj
        return page->add(obj);
    } else if (page) {
        // 如果满了，方法内部向下寻找没满的子节点，并存入obj；如果没有，就新建一个节点
        return autoreleaseFullPage(obj, page);
    } else {
        // 新建一个节点并存入obj
        return autoreleaseNoPage(obj);
    }
}

// 逻辑大致如上，只是没有判断hotPage是否满了
static __attribute__((noinline))
id *autoreleaseNewPage(id obj)
{
    AutoreleasePoolPage *page = hotPage();
    if (page) return autoreleaseFullPage(obj, page);
    else return autoreleaseNoPage(obj);
}

push操作内部会有一些逻辑分支，条件如上面代码注释，最终的目的都是找到或创建一个page将指针存进去。既然要存新指针，autoreleaseFullPage(obj, page)和autoreleaseNoPage(obj)内部最终也都调用了page->add(obj)方法。add方法很简单，指针存入hotPage顶部（next），顶部加1：

id *add(id obj)
{
    ASSERT(!full());
    unprotect();
    id *ret = next;  // faster than `return next-1` because of aliasing
    // next指向的空间存入obj，然后加1
    *next++ = obj;
    protect();
    // 返回存入的位置
    return ret;
}

显然存储的目的就是为了在[pool drain]，也就是pop操作的时候向被存入的对象发送release消息。

AutoreleasePoolPage::pop(ctxt)

pop的代码有点多，这里就不贴出来了。
概括来讲就是要找到ctxt对应的page，并将比ctxt晚入栈的对象全部出栈，并调用方法：objc_release(obj)，也就是[obj release]。可以对照三.1中的这段注释来理解：

// 每个pool会有一个token指针，指向pool的POOL_BOUNDARY（哨兵）。当这个pool执行出栈操作时，每一个比这个哨兵后入栈的对象都会被released。

AutoreleasePoolPage:: autorelease(obj)

上面1中提到，autorelease pool栈中存放的指针有两种：指向需要release的对象或者POOL_BOUNDARY。
上面的push和pop操作针对的就是POOL_BOUNDARY，而这里要讲的方法的操作对象就是pool drain时需要release的对象。
其方法实现很简单，内部调用的autoreleaseFast方法上面也讲过了。
我们知道，当通过遍历构造器，比如“NSString *str = [NSString stringWithFormat:@"%@", xxx]”创建对象的时候，方法内部执行了“[str autorelease]”。而这时底层就通过调用“AutoreleasePoolPage:: autorelease(str)”，将str加入自动释放池。

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

源码的部分先到这，主要的结构和方法都提到了，还有很多细节和值得深挖的地方，留给你自己。

四、Autorelease Pool的使用场景

autorelease pool是为引用计数机制服务的，我们创建的所有需要autorelease的对象，都要在一个pool中进行。

主线程在每一个runloop的circle开始时都会自动创建一个pool，然后在结束时自动调用[pool drain]。所以我们在主线程中如果没有特殊需求不需要手动创建autorelease pool。有特殊需求的情况见3。
在子线程中，如果我们调用了诸如“NSString *str = [NSString stringWithFormat:@"%@", xxx]这类的方法，就需要自动释放池，这时我们必须手动创建autorelease pool，否则会导致leak。但是如果我们只用[[MyClass alloc] init]方法来创建对象，因为它们出了作用域就会被自动销毁，则不需要我们手动创建池子了。
另一个被广泛讨论的场景就是在主线程（子线程中如果我们开启了runloop，当然也一样）的一个循环中短时间创建大量对象，如果我们不想等到当前runloop的circle结束时才释放这些对象（这时内存可能已经暴涨很多了），就可以在循环体中手动创建一个pool，使得每次循环结束时都将本次循环中产生的临时变量及时释放掉。

五、Swift中的Autorelease Pool

Swift工程的程序入口标记为@UIApplicationMain，没有了main.m，也就看不到@autoreleasepool {}了。
Swift中还需不需要使用autorelease pool？
Swift 1.0时还有各种对应OC中遍历构造器的创建对象的方法，比如“String.stringWithFormat”。而从Swift 1.1开始这类方法都被废弃了，我们基本都只能使用init方法来创建对象，这种情况下就不需要autorelease pool了。（这点是从喵神15年的博客看来的...那时候我还没开始学习Swift。）
不过，我发现现在还有一些类似的api存在，比如：

public class func localizedStringWithFormat(_ format: NSString, _ args: CVarArg...) -> Self

如果使用这类方法的话，应该还需要autorelease pool吧。？

Swift中autorelease pool的使用形式不再是@autoreleasepool {}，去掉了“@”符号，直接是autoreleasepool {}，其实是一个函数，还有返回值。

public func autoreleasepool<Result>(invoking body: () throws -> Result) rethrows -> Result

Autorelease Pool的底层实现和相关事项总结

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读