63 (OC)* NSAutoreleasePool 自动释放池

目录

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都是以双链表的形式连接起来的

63  (OC)*  NSAutoreleasePool 自动释放池

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

b:  自动释放池中的栈

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

63  (OC)*  NSAutoreleasePool 自动释放池

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

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

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

63  (OC)*  NSAutoreleasePool 自动释放池

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:

63  (OC)*  NSAutoreleasePool 自动释放池

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,如下图一样释放对象:

63  (OC)*  NSAutoreleasePool 自动释放池

2.11:  push和pop操作

a: push

63  (OC)*  NSAutoreleasePool 自动释放池

一个 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 ;

63  (OC)*  NSAutoreleasePool 自动释放池

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

3:autorelease 方法

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

63  (OC)*  NSAutoreleasePool 自动释放池

在 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 消息

上一篇:java5 ReadWriteLock用法--读写锁实现


下一篇:华为OJ平台——将真分数分解为埃及分数