63 (OC)* NSAutoreleasePool 自动释放池

2022-02-25 18:47:48

0：ARC

1: 自动释放池

2：NSAutoreleasePool实现原理

3：autorelease 方法

4： Runloop和Autorelease的关系

5： Using Autorelease Pool Blocks

正文

0：ARC

当您向一个对象发送一个autorelease消息时，Cocoa就会将该对象的一个引用放入到最新的自动释放池。它仍然是个正当的对象，因此自动释放池定义的作用域内的其它对象可以向它发送消息。当程序执行到作用域结束的位置时，自动释放池就会被释放，池中的所有对象也就被释放。
1. ojc-c 是通过一种"referring counting"(引用计数)的方式来管理内存的, 对象在开始分配内存(alloc)的时候引用计数为一,以后每当碰到有alloc,new，copy,retain的时候引用计数都会加一, 每当碰到release和autorelease的时候引用计数就会减一,如果此对象的计数变为了0, 就会被系统销毁.
2. NSAutoreleasePool 就是用来做引用计数的管理工作的,这个部分后面会详细说到.
3. autorelease和release没什么区别,只是引用计数减一的时机不同而已,autorelease会在对象的使用真正结束的时候才做引用计数减一.
4.设定项目编译环境为ARC下时，编译器会帮助我们在程序的入口main函数就调用NSAutoreleasePool，这样保证程序中不调用NSAutoreleasePool，但在退出时自动释放

1: 自动释放池

1.1: 什么是自动释放池

OC中的一种内存自动回收机制，它可以延迟加入AutoreleasePool中的变量release的时机，即当我们创建了一个对象，并把他加入到了自动释放池中时，他不会立即被释放，

a: 会等到一次runloop结束

b: 或者作用域超出{}

c: 或者超出[pool release]之后再被释放

1.2:自动释放池的创建与销毁时机

MRC：

NSAutoreleasePool *pool = [[ NSAutoreleasePool alloc]init ];//创建一个自动释放池

Person *person = [[Person alloc]init];

//调autorelease方法将对象加入到自动释放池

[person autorelease];

//手动释放自动释放池执行完这行代码是，自动释放池会对加入他中的对象做一次release操作

[pool release];

// 自动释放池销毁时机：[pool release]代码执行完后.

ARC

@autoreleasepool {

    //在这个{}之内的变量默认被添加到自动释放池

    Person *p = [[Person alloc] init];

}//除了这个括号，p被释放

：NSAutoreleasePool实现原理

2.1：从 main 函数开始

int main(int argc, const char * argv[]) {

    @autoreleasepool {

        // insert code here...

        NSLog(@"Hello, World!");

    }

    return ;

}

在这个 @autoreleasepool block 中只包含了一行代码，这行代码将所有的事件、消息全部交给了 UIApplication 来处理，但是这不是本文关注的重点。

需要注意的是：整个 iOS 的应用都是包含在一个自动释放池 block 中的。

2.2：@autoreleasepool

2.1：@autoreleasepool 到底是什么？我们在命令行中使用 clang -rewrite-objc main.m 让编译器重新改写这个文件：

$ clang -rewrite-objc main.m

int main(int argc, const char * argv[]) {

    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 

        NSLog((NSString *)&__NSConstantStringImpl__var_folders_49_sdbnp0nd07q4m_sh4_gw52r40000gn_T_main_9e48ee_mi_0);

    }

    return ;

}

在这个文件中，有一个非常奇怪的 __AtAutoreleasePool 的结构体，前面的注释写到 /* @autoreleasepopl */。也就是说 @autoreleasepool {} 被转换为：__AtAutoreleasePool的结构体。

2.2：通过对比可以发现，苹果通过声明一个__AtAutoreleasePool类型的局部变量 @autoreleasepool被转转换成__AtAutoreleasePool 结构体类型

struct __AtAutoreleasePool {

  __AtAutoreleasePool() {atautoreleasepoolobj = objc_autoreleasePoolPush();}

  ~__AtAutoreleasePool() {objc_autoreleasePoolPop(atautoreleasepoolobj);}

  void * atautoreleasepoolobj;

};

可以看到：

__AtAutoreleasePool() 构造函数调用objc_autoreleasePoolPush(),

~__AtAutoreleasePool() 析构函数调用 objc_autoreleasePoolPop()

2.3：这表明，我们的 main 函数其实是这样的：

int main(int argc, const char * argv[]) {

    {

        void * atautoreleasepoolobj = objc_autoreleasePoolPush();

        // do whatever you want

        objc_autoreleasePoolPop(atautoreleasepoolobj);

    }

    return ;

}

@autoreleasepool 只是帮助我们少写了这两行代码而已，让代码看起来更美观，然后要根据上述两个方法来分析自动释放池的实现

2.4: objc_autoreleasePoolPush 和 objc_autoreleasePoolPop 是什么呢？

在 NSObject.mm 文件中：

void *objc_autoreleasePoolPush(void) {

        return AutoreleasePoolPage::push();

    }

void objc_autoreleasePoolPop(void *ctxt) {

        AutoreleasePoolPage::pop(ctxt);

    }

实际上是调用AutoreleasePoolPage的push和pop两个类方法

上面的方法看上去是对 AutoreleasePoolPage 对应静态方法 push 和 pop 的封装。

2.5: 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;

    }

magic：用来校验 AutoreleasePoolPage 的结构是否完整；

next：指向栈顶，也就是最新入栈的autorelease对象的下一个位置；

thread: 保存了当前页所在的线程

parent：指向父节点

child：指向子节点

depth：表示链表的深度，也就是链表节点的个数

hiwat：表示high water mark（最高水位标记）

当 next == begin() 时，表示 AutoreleasePoolPage 为空；当 next == end() 时，表示 AutoreleasePoolPage 已满。

2.6: 每一个自动释放池都是由一系列的 AutoreleasePoolPage 组成的，并且每一个 AutoreleasePoolPage 的大小都是字节（16 进制 0x1000）

#define I386_PGBYTES 4096

#define PAGE_SIZE I386_PGBYTES

a:　AutoreleasePoolPage 是一个 C++ 中的类：

每一个AutoreleasePoolPage都是以双链表的形式连接起来的

parent指向前一个page , child指向下一个page

b: 自动释放池中的栈

如果我们的一个 AutoreleasePoolPage 被初始化在内存的 0x100816000 ~ 0x100817000 中，它在内存中的结构如下：

其中有 56 bit 用于存储 AutoreleasePoolPage 的成员变量，剩下的 0x100816038 ~ 0x100817000 都是用来存储加入到自动释放池中的对象。

begin() 和 end() 这两个类的实例方法帮助我们快速获取 0x100816038 ~ 0x100817000 这一范围的边界地址。

next 指向了下一个为空的内存地址，如果 next 指向的地址加入一个 object，它就会如下图所示移动到下一个为空的内存地址中：

2.7: POOL_SENTINEL（哨兵对象）

到了这里，你可能想要知道 POOL_SENTINEL 到底是什么，还有它为什么在栈中。

首先回答第一个问题： POOL_SENTINEL 只是 nil 的别名。

#define POOL_SENTINEL nil

在每个自动释放池初始化调用 objc_autoreleasePoolPush 的时候，都会把一个 POOL_SENTINEL push 到自动释放池的栈顶，并且返回这个 POOL_SENTINEL 哨兵对象。

int main(int argc, const char * argv[]) {

    {

        void * atautoreleasepoolobj = objc_autoreleasePoolPush();

        // do whatever you want

        objc_autoreleasePoolPop(atautoreleasepoolobj);

    }

    return ;

}

上面的 atautoreleasepoolobj 就是一个 POOL_SENTINEL。

而当方法 objc_autoreleasePoolPop 调用时，就会向自动释放池中的对象发送 release 消息，直到第一个 POOL_SENTINEL：

2.8: objc_autoreleasePoolPush 方法

了解了 POOL_SENTINEL，我们来重新回顾一下 objc_autoreleasePoolPush 方法：

void *objc_autoreleasePoolPush(void) {

    return AutoreleasePoolPage::push();

}

它调用 AutoreleasePoolPage 的类方法 push，也非常简单：

tatic inline void *push() {

   return autoreleaseFast(POOL_SENTINEL);

}

在这里会进入一个比较关键的方法 autoreleaseFast，并传入哨兵对象 POOL_SENTINEL：

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 不满
- 调用 page->add(obj) 方法将对象添加至 AutoreleasePoolPage 的栈中
有 hotPage 并且当前 page 已满
- 调用 autoreleaseFullPage 初始化一个新的页
- 调用 page->add(obj) 方法将对象添加至 AutoreleasePoolPage 的栈中
无 hotPage
- 调用 autoreleaseNoPage 创建一个 hotPage
- 调用 page->add(obj) 方法将对象添加至 AutoreleasePoolPage 的栈中

最后的都会调用 page->add(obj) 将对象添加到自动释放池中。

hotPage 可以理解为当前正在使用的 AutoreleasePoolPage

2.9: page->add 添加对象

id *add(id obj) 将对象添加到自动释放池页中：

id *add(id obj) {

    id *ret = next;

    *next = obj;

    next++;

    return ret;

}

这个方法其实就是一个压栈的操作，将对象加入 AutoreleasePoolPage 然后移动栈顶的指针。

a: autoreleaseFullPage（当前 hotPage 已满）

autoreleaseFullPage 会在当前的 hotPage 已满的时候调用：

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

}

它会从传入的 page 开始遍历整个双向链表，直到：

查找到一个未满的 AutoreleasePoolPage

使用构造器传入 parent 创建一个新的 AutoreleasePoolPage

在查找到一个可以使用的 AutoreleasePoolPage 之后，会将该页面标记成 hotPage，然后调动上面分析过的 page->add 方法添加对象。

b: autoreleaseNoPage（没有 hotPage)

如果当前内存中不存在 hotPage，就会调用 autoreleaseNoPage 方法初始化一个 AutoreleasePoolPage：

static id *autoreleaseNoPage(id obj) {

    AutoreleasePoolPage *page = new AutoreleasePoolPage(nil);

    setHotPage(page);

    if (obj != POOL_SENTINEL) {

        page->add(POOL_SENTINEL);

    }

    return page->add(obj);

}

既然当前内存中不存在 AutoreleasePoolPage，就要从头开始构建这个自动释放池的双向链表，也就是说，新的 AutoreleasePoolPage 是没有 parent 指针的。

初始化之后，将当前页标记为 hotPage，然后会先向这个 page 中添加一个 POOL_SENTINEL 对象，来确保在 pop 调用的时候，不会出现异常。

最后，将 obj 添加到自动释放池中。

2.10: objc_autoreleasePoolPop 方法

同样，回顾一下上面提到的 objc_autoreleasePoolPop 方法：

void objc_autoreleasePoolPop(void *ctxt) {

    AutoreleasePoolPage::pop(ctxt);

}

看起来传入任何一个指针都是可以的，但是在整个工程并没有发现传入其他对象的例子。不过在这个方法中传入其它的指针也是可行的，会将自动释放池释放到相应的位置。

我们一般都会在这个方法中传入一个哨兵对象 POOL_SENTINEL，如下图一样释放对象：

2.11: push和pop操作

a: push

一个 push 操作其实就是创建一个新的 autoreleasepool ，对应 AutoreleasePoolPage 的具体实现就是往 AutoreleasePoolPage 中的 next 位置插入一个 POOL_SENTINEL ，并且返回插入的 POOL_SENTINEL 的内存地址。

每调用一次 push 操作就会创建一个新的 AutoreleasePoolPage ，即往 AutoreleasePoolPage 中插入一个 POOL_SENTINEL ，并且返回插入的 POOL_SENTINEL 的内存地址。

POOL_BOUNDARY（哨兵对象，代表一个 autoreleasepool 的边界）

调用push方法会将一个POOL_BOUNDARY入栈，并且返回其存放的内存地址
调用pop方法时传入一个POOL_BOUNDARY的内存地址，会从最后一个入栈的对象开始发送release消息，直到遇到这个POOL_BOUNDARY
id *next指向了下一个能存放autorelease对象地址的区域

b: pop操作

一个 pool token 就是这个 pool 所对应的 POOL_SENTINEL 的内存地址。当这个 pool 被 pop 的时候，所有内存地址在 pool token 之后的对象都会被 release ；

pop 函数的入参就是 push 函数的返回值，也就是 POOL_SENTINEL 的内存地址即 pool token 。当执行 pop 操作时，内存地址在 pool token 之后的所有 autoreleased 对象都会被 release 。直到 pool token 所在 page 的 next 指向 pool token 为止。

3：autorelease 方法

我们已经对自动释放池生命周期有一个比较好的了解，最后需要了解的话题就是 autorelease 方法的实现，先来看一下方法的调用栈：

在 autorelease 方法的调用栈中，最终都会调用上面提到的 autoreleaseFast 方法，将当前对象加到 AutoreleasePoolPage 中。

4： Runloop和Autorelease的关系

1: App启动后，苹果在主线程 RunLoop 里注册了两个 Observer，其回调都是 _wrapRunLoopWithAutoreleasePoolHandler()。

第一个 Observer 监视的事件是 Entry(即将进入Loop)，其回调内会调用 _objc_autoreleasePoolPush() 创建自动释放池。其 order 是-2147483647，优先级最高，保证创建释放池发生在其他所有回调之前。

第二个 Observer 监视了两个事件： BeforeWaiting(准备进入休眠) 时调用_objc_autoreleasePoolPop() 和 _objc_autoreleasePoolPush() 释放旧的池并创建新池；Exit(即将退出Loop) 时调用 _objc_autoreleasePoolPop() 来释放自动释放池。这个 Observer 的 order 是 2147483647，优先级最低，保证其释放池子发生在其他所有回调之后。

在主线程执行的代码，通常是写在诸如事件回调、Timer回调内的。这些回调会被 RunLoop 创建好的 AutoreleasePool 环绕着，所以不会出现内存泄漏，开发者也不必显示创建 Pool 了。

2：同样的，根据苹果官方文档中对 NSAutoreleasePool 的描述，我们可知，在主线程的 NSRunLoop 对象（在系统级别的其他线程中应该也是如此，比如通过 dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0) 获取到的线程）的每个 event loop 开始前，系统会自动创建一个 autoreleasepool ，并在 event loop 结束时 drain 。我们上面提到的场景 1 中创建的 autoreleased 对象就是被系统添加到了这个自动创建的 autoreleasepool 中，并在这个 autoreleasepool 被 drain 时得到释放。

3：另外，NSAutoreleasePool 中还提到，每一个线程都会维护自己的 autoreleasepool 堆栈。换句话说 autoreleasepool 是与线程紧密相关的，每一个 autoreleasepool 只对应一个线程。

5： Using Autorelease Pool Blocks

根据苹果官方文档中对 Using Autorelease Pool Blocks 的描述，我们知道在下面三种情况下是需要我们手动添加 autoreleasepool 的：

1：如果你编写的程序不是基于 UI 框架的，比如说命令行工具；

2：如果你编写的循环中创建了大量的临时对象；

3：如果你创建了一个辅助线程

总结

整个自动释放池 AutoreleasePool 的实现以及 autorelease 方法都已经分析完了，我们再来回顾一下文章中的一些内容：

自动释放池是由 AutoreleasePoolPage 以双向链表的方式实现的
当对象调用 autorelease 方法时，会将对象加入 AutoreleasePoolPage 的栈中
调用 AutoreleasePoolPage::pop 方法会向栈中的对象发送 release 消息

码农公寓

0：ARC

1: 自动释放池

1.1: 什么是自动释放池

1.2:自动释放池的创建与销毁时机

MRC：

ARC

：NSAutoreleasePool实现原理

2.1：从 main 函数开始

2.2：@autoreleasepool

POOL_BOUNDARY（哨兵对象，代表一个 autoreleasepool 的边界）

3：autorelease 方法

4： Runloop和Autorelease的关系

5： Using Autorelease Pool Blocks

总结

相关文章