http://draveness.me/autoreleasepool.html

关注仓库,及时获得更新:iOS-Source-Code-Analyze

Follow: Draveness · Github

由于 Objective-C 中的内存管理是一个比较大的话题,所以会分为两篇文章来对内存管理中的一些机制进行剖析,一部分分析自动释放池以及 autorelease 方法,另一部分分析 retainrelease 方法的实现以及自动引用计数。

写在前面

这篇文章会在源代码层面介绍 Objective-C 中自动释放池,以及方法的 autorelease 的具体实现。

从 main 函数开始

main 函数可以说是在整个 iOS 开发中非常不起眼的一个函数,它很好地隐藏在 Supporting Files 文件夹中,却是整个 iOS 应用的入口。

main.m 文件中的内容是这样的:

int main(int argc, char * argv[]) {
@autoreleasepool {
return UIApplicationMain(argc, argv, nil, NSStringFromClass([AppDelegate class]));
}
}

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

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

@autoreleasepool

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

$ clang -rewrite-objc main.m

在生成了一大堆警告之后,当前目录下多了一个 main.cpp 文件

这里删除了 main 函数中其他无用的代码。

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

{
__AtAutoreleasePool __autoreleasepool;
}

想要弄清楚这行代码的意义,我们要在 main.cpp 中查找名为 __AtAutoreleasePool 的结构体:

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

这个结构体会在初始化时调用 objc_autoreleasePoolPush() 方法,会在析构时调用 objc_autoreleasePoolPop 方法。

这表明,我们的 main 函数在实际工作时其实是这样的:

int main(int argc, const char * argv[]) {
{
void * atautoreleasepoolobj = objc_autoreleasePoolPush(); // do whatever you want objc_autoreleasePoolPop(atautoreleasepoolobj);
}
return 0;
}

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

AutoreleasePool 是什么

这一节开始分析方法 objc_autoreleasePoolPush 和 objc_autoreleasePoolPop 的实现:

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

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

这一小节会按照下面的顺序逐步解析代码中的内容:

AutoreleasePoolPage 的结构

AutoreleasePoolPage 是一个 C++ 中的类:

它在 NSObject.mm 中的定义是这样的:

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 完整性的校验
  • thread 保存了当前页所在的线程

每一个自动释放池都是由一系列的 AutoreleasePoolPage 组成的,并且每一个 AutoreleasePoolPage 的大小都是 4096 字节(16 进制 0x1000)

#define I386_PGBYTES 4096
#define PAGE_SIZE I386_PGBYTES

双向链表

自动释放池中的 AutoreleasePoolPage 是以双向链表的形式连接起来的:

parent 和 child 就是用来构造双向链表的指针。

自动释放池中的栈

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

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

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

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

关于 hiwat 和 depth 在文章中并不会进行介绍,因为它们并不影响整个自动释放池的实现,也不在关键方法的调用栈中。

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

上面的 atautoreleasepoolobj 就是一个 POOL_SENTINEL

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

objc_autoreleasePoolPush 方法

了解了 POOL_SENTINEL,我们来重新回顾一下 objc_autoreleasePoolPush 方法:

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

它调用 AutoreleasePoolPage 的类方法 push,也非常简单:

static 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

page->add 添加对象

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

id *add(id obj) {
id *ret = next;
*next = obj;
next++;
return ret;
}

笔者对这个方法进行了处理,更方便理解。

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

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 开始遍历整个双向链表,直到:

  1. 查找到一个未满的 AutoreleasePoolPage
  2. 使用构造器传入 parent 创建一个新的 AutoreleasePoolPage

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

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 添加到自动释放池中。

objc_autoreleasePoolPop 方法

同样,回顾一下上面提到的 objc_autoreleasePoolPop 方法:

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

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

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

对 objc_autoreleasePoolPop 行为的测试

在继续分析这个方法之前做一个小测试,在 objc_autoreleasePoolPop 传入非哨兵对象,测试一下这个方法的行为。

下面是 main.m 文件中的源代码:

#import <Foundation/Foundation.h>

int main(int argc, const char * argv[]) {
@autoreleasepool { NSString *s = @"Draveness";
[s stringByAppendingString:@"-Suffix"]; }
return 0;
}

在代码的这一行打一个断点,因为这里会调用 autorelease 方法,将字符串加入自动释放池:

当代码运行到这里时,通过 lldb 打印出当前 hotPage 中的栈内容:

  1. 通过 static 方法获取当前 hotPage
  2. 打印 AutoreleasePoolPage 中的内容
  3. 打印当前 next 指针指向的内容,以及之前的内容,-2时已经到了 begin() 位置
  4. 使用 print()和 printAll()打印自动释放池中内容

然后将字符串 @"Draveness-Suffix" 的指针传入 pop 方法,测试 pop 方法能否传入非哨兵参数。

再次打印当前 AutoreleasePoolPage 的内容时,字符串已经不存在了,这说明向 pop 方法传入非哨兵参数是可行的,只是我们一般不会传入非哨兵对象。


让我们重新回到对 objc_autoreleasePoolPop 方法的分析,也就是 AutoreleasePoolPage::pop 方法的调用:

static inline void pop(void *token) {
AutoreleasePoolPage *page = pageForPointer(token);
id *stop = (id *)token; page->releaseUntil(stop); if (page->child) {
if (page->lessThanHalfFull()) {
page->child->kill();
} else if (page->child->child) {
page->child->child->kill();
}
}
}

在这个方法中删除了大量无关的代码,以及对格式进行了调整。

该静态方法总共做了三件事情:

  1. 使用 pageForPointer 获取当前 token 所在的 AutoreleasePoolPage
  2. 调用 releaseUntil 方法释放栈中的对象,直到 stop
  3. 调用 child 的 kill 方法

我到现在也不是很清楚为什么要根据当前页的不同状态 kill 掉不同 child 的页面。

if (page->lessThanHalfFull()) {
page->child->kill();
} else if (page->child->child) {
page->child->child->kill();
}

pageForPointer 获取 AutoreleasePoolPage

pageForPointer 方法主要是通过内存地址的操作,获取当前指针所在页的首地址:

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

将指针与页面的大小,也就是 4096 取模,得到当前指针的偏移量,因为所有的 AutoreleasePoolPage 在内存中都是对齐的:

p = 0x100816048
p % SIZE = 0x48
result = 0x100816000

而最后调用的方法 fastCheck() 用来检查当前的 result 是不是一个 AutoreleasePoolPage

通过检查 magic_t 结构体中的某个成员是否为 0xA1A1A1A1

releaseUntil 释放对象

releaseUntil 方法的实现如下:

void releaseUntil(id *stop) {
while (this->next != stop) {
AutoreleasePoolPage *page = hotPage(); while (page->empty()) {
page = page->parent;
setHotPage(page);
} page->unprotect();
id obj = *--page->next;
memset((void*)page->next, SCRIBBLE, sizeof(*page->next));
page->protect(); if (obj != POOL_SENTINEL) {
objc_release(obj);
}
} setHotPage(this);
}

它的实现还是很容易的,用一个 while 循环持续释放 AutoreleasePoolPage 中的内容,直到 next 指向了 stop 。

使用 memset 将内存的内容设置成 SCRIBBLE,然后使用 objc_release 释放对象。

kill() 方法

到这里,没有分析的方法就只剩下 kill 了,而它会将当前页面以及子页面全部删除:

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

autorelease 方法

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

- [NSObject autorelease]
└── id objc_object::rootAutorelease()
└── id objc_object::rootAutorelease2()
└── static id AutoreleasePoolPage::autorelease(id obj)
└── static id AutoreleasePoolPage::autoreleaseFast(id obj)
├── id *add(id obj)
├── static id *autoreleaseFullPage(id obj, AutoreleasePoolPage *page)
│ ├── AutoreleasePoolPage(AutoreleasePoolPage *newParent)
│ └── id *add(id obj)
└── static id *autoreleaseNoPage(id obj)
├── AutoreleasePoolPage(AutoreleasePoolPage *newParent)
└── id *add(id obj)

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

这一小节中这些方法的实现都非常容易,只是进行了一些参数上的检查,最终还要调用 autoreleaseFast 方法:

inline id objc_object::rootAutorelease() {
if (isTaggedPointer()) return (id)this;
if (prepareOptimizedReturn(ReturnAtPlus1)) return (id)this; return rootAutorelease2();
} __attribute__((noinline,used)) id objc_object::rootAutorelease2() {
return AutoreleasePoolPage::autorelease((id)this);
} static inline id autorelease(id obj) {
id *dest __unused = autoreleaseFast(obj);
return obj;
}

由于在上面已经分析过 autoreleaseFast 方法的实现,这里就不会多说了。

小结

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

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

参考资料

自动释放池的前世今生 ---- 深入解析 autoreleasepool的更多相关文章

  1. C++模拟OC的多重自动释放池

    使用过OC的都知道,OC的引用计数机制用起来还比较方便.于是就仿照OC的形式搞了个C++引用计数. 支持多重自动释放池,每次autorelease都会放到栈顶的自动释放池中. 自动释放池也可以像变量一 ...

  2. autoreleasepool自动释放池

     示例: @autoreleasepool { ; i[largeNumber; i++) { (因识别问题,该行代码中尖括号改为方括号代替) Person *per = [[Person alloc ...

  3. autoreleasepool 自动释放池的理解

    常见的面试题:以下代码存在什么样的问题?应该如何改进? for (int i = 0; i < 100000; i++) { NSString *str = @"abc"; ...

  4. OC自动释放池autoreleasepool介绍

    自动释放池的机制是:它使得应用在创建新对象时,系统能够有效地管理应用所使用的内存. @autoreleasepool { statements } 在创建新对象时,并且系统未启动ARC特性,那么在使用 ...

  5. 刀哥多线程自动释放池autoreleasepool

    自动释放池 作用 自动释放对象的 所有 autorelease 的对象,在出了作用域之后,会被自动添加到最近创建的自动释放池中 自动释放池被销毁或者耗尽时,会向池中所有对象发送 release 消息, ...

  6. 自动释放池autoreleasepool

    自动释放池是NSAutoreleasePool的实例,其中包含了收到autorelease消息的对象.当一个自动释放池自身被销毁(dealloc)时,它会给池中每一个对象发送一个release消息(如 ...

  7. (20)Cocos2d-x中的引用计数(Reference Count)和自动释放池(AutoReleasePool)

    引用计数 引用计数是c/c++项目中一种古老的内存管理方式.当我8年前在研究一款名叫TCPMP的开源项目的时候,引用计数就已经有了. iOS SDK把这项计数封装到了NSAutoreleasePool ...

  8. Autorelease自动释放池的使用

    Autorelease自动释放池的使用 使用ARC开发,只是在编译时,编译器会根据代码结构自动添加了retain.release和autorelease. MRC内存管理原则:谁申请,谁释放 遇到al ...

  9. OC 内存泄露 自动释放池

    花絮:看到下面的代码就想起这么一个调侃: 一个老程序员,功成名就,金盆洗手不在写代码后,决定练练书法.提笔思索良久后在纸上写下:Hello world! /********************** ...

随机推荐

  1. KONG -- 图形化管理(Kong Dashboard)

    前面安装的 KONG 的版本是社区版的 1.0.2,官方的 KONG Manager 好像只有企业版才提供.在 github 上找了一个开源的图形化管理应用 -- Kong Dashboard (ht ...

  2. hdu 1848 Fibonacci again and again(SG函数)

    Fibonacci again and again HDU - 1848 任何一个大学生对菲波那契数列(Fibonacci numbers)应该都不会陌生,它是这样定义的: F(1)=1; F(2)= ...

  3. day01笔记

    linux基本命令的学习: 1.查看主机名 hostname 2.修改主机名 hostnamectl set-hostname s16ds 3.linux命令提示符 [root@s16ds ~]# # ...

  4. Asp.net Core 添加 EF 工具并执行初始迁移错误解决方法(Add-Migration Initial---Build failed.)

    1.问题: 首次在ASP.NET Core项目中使用Code First模式的Entity Framework框架,在添加EF工具并做初始化迁移(perform initial migration), ...

  5. Codeforces Round #129 (Div. 2) A

    Description The Little Elephant loves Ukraine very much. Most of all he loves town Rozdol (ukr. &quo ...

  6. lintcode-dfs实现二叉树的层序遍历

    class Solution { /** * @param root: The root of binary tree. * @return: Level order a list of lists ...

  7. lifecycle-mapping-metadata.xml

    <?xml version="1.0" encoding="UTF-8"?> <lifecycleMappingMetadata> &l ...

  8. 分析师分析业务维度,(个人制作分析思维导图Xmind)

    个人在咨询公司做过分析师(分析师必须懂运营),该咨询公司主要针对电商,零售 结合公司的搭建的CRM系统及报表体系,列了个分析师分析维度,搭建公司自己的BI系统 个人经验:分析师的分析思维可以多看看艾瑞 ...

  9. web 中防止sql注入

    public class SqlInject:Page { //检测到注入后的处理方式: 0:仅警告:1:警告+记录:2:警告+自定义错误页面:3:警告+记录+自定义错误页面 ; private co ...

  10. (四)Redis主从复制(单机版,不集群)

    持久化保证了即使redis服务重启也不会丢失数据,因为redis服务重启后会将硬盘上持久化的数据恢复到内存中,但是当redis服务器的硬盘损坏了可能会导致数据丢失,如果通过redis的主从复制机制就可 ...