autoreleasepool底层详解
2016-05-17 10:30
337 查看
由于 Objective-C 中的内存管理是一个比较大的话题,所以会分为两篇文章来对内存管理中的一些机制进行剖析,一部分分析自动释放池以及
在这个
需要注意的是:整个 iOS 的应用都是包含在一个自动释放池 block 中的。
在生成了一大堆警告之后,当前目录下多了一个
这里删除了
在这个文件中,有一个非常奇怪的
想要弄清楚这行代码的意义,我们要在
这个结构体会在初始化时调用
这表明,我们的
上面的方法看上去是对
这一小节会按照下面的顺序逐步解析代码中的内容:
AutoreleasePoolPage 的结构
objc_autoreleasePoolPush 方法
objc_autoreleasePoolPop 方法
它在
每一个自动释放池都是由一系列的
进制 0x1000)
其中有 56 bit 用于存储
关于
首先回答第一个问题:
在每个自动释放池初始化调用
到自动释放池的栈顶,并且返回这个
上面的
而当方法
它调用
在这里会进入一个比较关键的方法
上述方法分三种情况选择不同的代码执行:
有
调用
有
调用
调用
无
调用
调用
最后的都会调用
笔者对这个方法进行了处理,更方便理解。
这个方法其实就是一个压栈的操作,将对象加入
它会从传入的
查找到一个未满的
使用构造器传入
在查找到一个可以使用的
既然当前内存中不存在
初始化之后,将当前页标记为
最后,将
看起来传入任何一个指针都是可以的,但是在整个工程并没有发现传入其他对象的例子。不过在这个方法中传入其它的指针也是可行的,会将自动释放池释放到相应的位置。
我们一般都会在这个方法中传入一个哨兵对象
下面是
在代码的这一行打一个断点,因为这里会调用
当代码运行到这里时,通过 lldb 打印出当前
通过
打印
打印当前
使用
然后将字符串
再次打印当前
让我们重新回到对
在这个方法中删除了大量无关的代码,以及对格式进行了调整。
该静态方法总共做了三件事情:
使用
调用
调用
我到现在也不是很清楚为什么要根据当前页的不同状态
将指针与页面的大小,也就是 4096 取模,得到当前指针的偏移量,因为所有的
而最后调用的方法
通过检查
它的实现还是很容易的,用一个
使用
在
这一小节中这些方法的实现都非常容易,只是进行了一些参数上的检查,最终还要调用autoreleaseFast 方法:
由于在上面已经分析过
自动释放池是由
当对象调用
调用
autorelease方法,另一部分分析
retain、
release方法的实现以及自动引用计数。
写在前面
这篇文章会在源代码层面介绍 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])); } }
在这个
@autoreleasepoolblock 中只包含了一行代码,这行代码将所有的事件、消息全部交给了
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 的结构
objc_autoreleasePoolPush 方法
objc_autoreleasePoolPop 方法
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_SENTINELpush
到自动释放池的栈顶,并且返回这个
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开始遍历整个双向链表,直到:
查找到一个未满的
AutoreleasePoolPage
使用构造器传入
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中的栈内容:
通过
static方法获取当前
hotPage
打印
AutoreleasePoolPage中的内容
打印当前
next指针指向的内容,以及之前的内容,
-2时已经到了
begin()位置
使用
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(); } } }
在这个方法中删除了大量无关的代码,以及对格式进行了调整。
该静态方法总共做了三件事情:
使用
pageForPointer获取当前
token所在的
AutoreleasePoolPage
调用
releaseUntil方法释放栈中的对象,直到
stop
调用
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消息
参考资料
相关文章推荐
- leetcode141: Linked List Cycle
- Session 初步(一) 之 Session 与 Cookie
- javascript学习——创建对象
- codevs 1282 约瑟夫问题(线段树)
- Dubbo分布式服务框架入门(附工程)
- Qt布局相关因素汇总
- Adaboost算法结合Haar-like特征
- STM32F4学习笔记12——RNG随机数发生器
- CentOS7 设置截图的快捷键
- MFC程序最小化到系统托盘
- 安装sublime及常用插件
- AngularJS学习(1)Expressions
- Postman用法简介-Http请求模拟工具
- Codeforces Round #353 (Div. 2)-B. Restoring Painting(数学)
- Xcode 插件优缺点对比(推荐 20 款插件)
- Windows下Nginx初入门
- scala学习-----01
- HDU_1087_Super Jumping! Jumping! Jumping!_dp
- 微软软件开发技术二十年回顾-COM、OLE、ActiveX及COM+篇
- Markdown简易语法及其他