详解autoreleasepool
本文首发于我的博客html
前言
文章开始以前，先想一想下面三种场景，分别输出什么呢？c++
注意str的长度不能过短git
注意str的长度不能过短github
注意str的长度不能过短objective-c
@interface ViewController ()
{
__weak NSString *string_weak;
}
@end
@implementation ViewController
- (void)viewDidLoad {
[super viewDidLoad];
// 场景一
// NSString *str = [NSString stringWithFormat:@"https://ityongzhen.github.io/"];
// string_weak = str;
// 场景二
// @autoreleasepool {
// NSString *str = [NSString stringWithFormat:@"https://ityongzhen.github.io/"];
// string_weak = str;
// }
//
// // 场景三
NSString *str = nil;
@autoreleasepool {
str = [NSString stringWithFormat:@"https://ityongzhen.github.io/"];
string_weak = str;
}
NSLog(@"string: %@ %s", string_weak,__func__);
}
- (void)viewWillAppear:(BOOL)animated{
[super viewWillAppear:animated];
NSLog(@"string: %@ %s", string_weak,__func__);
}
- (void)viewDidAppear:(BOOL)animated{
[super viewDidAppear:animated];
NSLog(@"string: %@ %s", string_weak,__func__);
}
复制代码
这个问题，暂时先放下，继续往下看。bash
autoreleasepool生成c++文件
有以下代码数据结构
@autoreleasepool {
NSObject *obj = [[NSObject alloc] init];
}
复制代码
执行命令xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc main.m -o main-arm64.cpp生成c++文件，其对应的代码以下所示。app
{ __AtAutoreleasePool __autoreleasepool;
NSObject *obj = ((NSObject *(*)(id, SEL))(void *)objc_msgSend)((id)((NSObject *(*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("NSObject"), sel_registerName("alloc")), sel_registerName("init"));
}
复制代码
简化一下也就是less
{
__AtAutoreleasePool __autoreleasepool;
NSObject *obj = [[NSObject alloc] init];
}
复制代码
其中__AtAutoreleasePool是什么呢？这是一个结构体，其内容以下，包含一个构造函数，在建立结构体的时候调用。一个析构函数，在结构体销毁的时候调用。iphone
struct __AtAutoreleasePool {
//构造函数，在建立结构体的时候调用
__AtAutoreleasePool() {
atautoreleasepoolobj = objc_autoreleasePoolPush();
}
//析构函数，在结构体销毁的时候调用
~__AtAutoreleasePool(){
objc_autoreleasePoolPop(atautoreleasepoolobj);
}
void * atautoreleasepoolobj;
};
复制代码
因此，放在一块儿就是在开始的时候调用 objc_autoreleasePoolPush()结束时候调用objc_autoreleasePoolPop(atautoreleasepoolobj)
struct __AtAutoreleasePool {
//构造函数，在建立结构体的时候调用
__AtAutoreleasePool() {
atautoreleasepoolobj = objc_autoreleasePoolPush();
}
// 写在autoreleasepool内的代码
NSObject *obj = [[NSObject alloc] init];
//析构函数，在结构体销毁的时候调用
~__AtAutoreleasePool(){
objc_autoreleasePoolPop(atautoreleasepoolobj);
}
void * atautoreleasepoolobj;
};
复制代码
源码分析
AutoreleasePoolPage
具体源码能够再Runtime源码中查看，从源码能够看到objc_autoreleasePoolPush()和objc_autoreleasePoolPop
void *
objc_autoreleasePoolPush(void)
{
return AutoreleasePoolPage::push();
}
void
objc_autoreleasePoolPop(void *ctxt)
{
AutoreleasePoolPage::pop(ctxt);
}
复制代码
也就是说，这两个函数都是操做AutoreleasePoolPage来实现的。
类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;
id * begin() {
return (id *) ((uint8_t *)this+sizeof(*this));
}
id * end() {
return (id *) ((uint8_t *)this+SIZE);
}
bool empty() {
return next == begin();
}
bool full() {
return next == end();
}
bool lessThanHalfFull() {
return (next - begin() < (end() - begin()) / 2);
}
...
}
复制代码
能够看出
AutoreleasePoolPage对象经过双向链表的形式链接在一块儿
其中
- magic 用来校验 AutoreleasePoolPage 的结构是否完整；
- next 指向最新添加的 autoreleased 对象的下一个位置，初始化时指向 begin() ；
- thread 指向当前线程；说明了，AutoreleasePoolPage和线程一一对应的。
- parent 指向父结点
- child 指向子结点
- depth 表明深度，从 0 开始，日后递增 1；
- hiwat 表明 high water mark 。
每一个AutoreleasePoolPage对象占用4096字节
- 每一个AutoreleasePoolPage对象占用4096字节内存，除了用来存放它内部的成员变量，剩下的空间用来存放autorelease对象的地址
#define I386_PGBYTES 4096 /* bytes per 80386 page */
#define PAGE_SIZE I386_PGBYTES
static size_t const SIZE = PAGE_MAX_SIZE
id * begin() {
return (id *) ((uint8_t *)this+sizeof(*this));
}
id * end() {
return (id *) ((uint8_t *)this+SIZE);
}
复制代码
从上面的源码中能够看出来
- 每一个
AutoreleasePoolPage有是4096字节, - 以及
begin指向的是开始存放autorelease对象的地方， end指向结尾的位置
AutoreleasePoolPage存不下了怎么办？
若是一个AutoreleasePoolPage存不下了，就会再建立一个AutoreleasePoolPage对象，第一个AutoreleasePoolPage对象的child指向第二个AutoreleasePoolPage对象，第二个AutoreleasePoolPage对象的parent指向第一个AutoreleasePoolPage对象。图形表示就是以下
push、pop、autorelease
AutoreleasePoolPage里面有push和pop函数
-
调用
push方法会将一个POOL_BOUNDARY入栈，而且返回其存放的内存地址 -
调用
pop方法时传入一个POOL_BOUNDARY的内存地址，会从最后一个入栈的对象开始发送release消息，直到遇到这个POOL_BOUNDARY -
id *next指向了下一个能存放autorelease对象地址的区域
push
static inline void *push()
{
id *dest;
if (DebugPoolAllocation) {
// Each autorelease pool starts on a new pool page.
dest = autoreleaseNewPage(POOL_BOUNDARY);
} else {
dest = autoreleaseFast(POOL_BOUNDARY);
}
assert(dest == EMPTY_POOL_PLACEHOLDER || *dest == POOL_BOUNDARY);
return dest;
}
复制代码
static inline id *autoreleaseFast(id obj)
{
AutoreleasePoolPage *page = hotPage();
if (page && !page->full()) {//page没有满，就把obj对象加到page
return page->add(obj);
} else if (page) {//page满了 建立新的page
return autoreleaseFullPage(obj, page);
} else {
return autoreleaseNoPage(obj);
}
}
复制代码
pop
static inline void pop(void *token)
{
AutoreleasePoolPage *page;
id *stop;
if (token == (void*)EMPTY_POOL_PLACEHOLDER) {
// Popping the top-level placeholder pool.
if (hotPage()) {
// Pool was used. Pop its contents normally.
// Pool pages remain allocated for re-use as usual.
pop(coldPage()->begin());
} else {
// Pool was never used. Clear the placeholder.
setHotPage(nil);
}
return;
}
page = pageForPointer(token);
stop = (id *)token;
if (*stop != POOL_BOUNDARY) {
if (stop == page->begin() && !page->parent) {
// Start of coldest page may correctly not be POOL_BOUNDARY:
// 1. top-level pool is popped, leaving the cold page in place
// 2. an object is autoreleased with no pool
} else {
// Error. For bincompat purposes this is not
// fatal in executables built with old SDKs.
return badPop(token);
}
}
if (PrintPoolHiwat) printHiwat();
page->releaseUntil(stop);
// memory: delete empty children
if (DebugPoolAllocation && page->empty()) {
// special case: delete everything during page-per-pool debugging
AutoreleasePoolPage *parent = page->parent;
page->kill();
setHotPage(parent);
} else if (DebugMissingPools && page->empty() && !page->parent) {
// special case: delete everything for pop(top)
// when debugging missing autorelease pools
page->kill();
setHotPage(nil);
}
else if (page->child) {
// hysteresis: keep one empty child if page is more than half full
if (page->lessThanHalfFull()) {
page->child->kill();
}
else if (page->child->child) {
page->child->child->kill();
}
}
}
复制代码
autorelease
inline id
objc_object::autorelease()
{
if (isTaggedPointer()) return (id)this;
// 调用rootAutorelease
if (fastpath(!ISA()->hasCustomRR())) return rootAutorelease();
return ((id(*)(objc_object *, SEL))objc_msgSend)(this, SEL_autorelease);
}
复制代码
rootAutorelease调用rootAutorelease2
inline id
objc_object::rootAutorelease()
{
if (isTaggedPointer()) return (id)this;
if (prepareOptimizedReturn(ReturnAtPlus1)) return (id)this;
return rootAutorelease2();
}
复制代码
rootAutorelease2调用autorelease
__attribute__((noinline,used))
id
objc_object::rootAutorelease2()
{
assert(!isTaggedPointer());
return AutoreleasePoolPage::autorelease((id)this);
}
复制代码
autorelease
static inline id autorelease(id obj)
{
assert(obj);
assert(!obj->isTaggedPointer());
//再次调用autoreleaseFast
id *dest __unused = autoreleaseFast(obj);
assert(!dest || dest == EMPTY_POOL_PLACEHOLDER || *dest == obj);
return obj;
}
复制代码
POOL_BOUNDARY
上面的源码能够发现POOL_BOUNDARY是个很重要的角色，至关于一个哨兵，
- 每当进行一次
objc_autoreleasePoolPush调用时，runtime向当前的AutoreleasePoolPage中add进一个哨兵对象(POOL_BOUNDARY)，值为0（也就是个nil） objc_autoreleasePoolPush的返回值正是这个哨兵对象的地址，被objc_autoreleasePoolPop(哨兵对象)做为入参，因而- 根据传入的哨兵对象地址找到哨兵对象所处的page
- 在当前page中，将晚于哨兵对象插入的全部autorelease对象都发送一次
- release消息，并向回移动next指针到正确位置 - 从最新加入的对象一直向前清理，能够向前跨越若干个page，直到哨兵所在的page
@autoreleasepool的嵌套
若是多个@autoreleasepool嵌套会怎么样呢？
打印
源码中有以下代码
void
_objc_autoreleasePoolPrint(void)
{
AutoreleasePoolPage::printAll();
}
static void printAll()
{
_objc_inform("##############");
_objc_inform("AUTORELEASE POOLS for thread %p", pthread_self());
AutoreleasePoolPage *page;
ptrdiff_t objects = 0;
for (page = coldPage(); page; page = page->child) {
objects += page->next - page->begin();
}
_objc_inform("%llu releases pending.", (unsigned long long)objects);
if (haveEmptyPoolPlaceholder()) {
_objc_inform("[%p] ................ PAGE (placeholder)",
EMPTY_POOL_PLACEHOLDER);
_objc_inform("[%p] ################ POOL (placeholder)",
EMPTY_POOL_PLACEHOLDER);
}
else {
for (page = coldPage(); page; page = page->child) {
page->print();
}
}
_objc_inform("##############");
}
复制代码
也就是说_objc_autoreleasePoolPrint函数能够用来打印一些日志
一层@autoreleasepool
extern void _objc_autoreleasePoolPrint(void);
int main(int argc, char * argv[]) {
@autoreleasepool {
_objc_autoreleasePoolPrint();
return UIApplicationMain(argc, argv, nil, NSStringFromClass([AppDelegate class]));
}
}
复制代码
输出以下，只有一个哨兵对象(POOL)
objc[32644]: ##############
objc[32644]: AUTORELEASE POOLS for thread 0x11b111d40
objc[32644]: 3 releases pending.
objc[32644]: [0x7fcabf802000] ................ PAGE (hot) (cold)
objc[32644]: [0x7fcabf802038] 0x600003f70500 __NSArrayI
objc[32644]: [0x7fcabf802040] 0x600000950f00 __NSSetI
objc[32644]: [0x7fcabf802048] ################ POOL 0x7fcabf802048
objc[32644]: ##############
复制代码
三层@autoreleasepool
若是有三个@autoreleasepool呢？
extern void _objc_autoreleasePoolPrint(void);
int main(int argc, char * argv[]) {
@autoreleasepool {
@autoreleasepool {
@autoreleasepool {
_objc_autoreleasePoolPrint();
}
}
return UIApplicationMain(argc, argv, nil, NSStringFromClass([AppDelegate class]));
}
}
复制代码
输出以下，有三个POOL，说明有三个哨兵。
objc[32735]: ##############
objc[32735]: AUTORELEASE POOLS for thread 0x114f02d40
objc[32735]: 5 releases pending.
objc[32735]: [0x7f91fd005000] ................ PAGE (hot) (cold)
objc[32735]: [0x7f91fd005038] 0x600001bbd380 __NSArrayI
objc[32735]: [0x7f91fd005040] 0x600002da4eb0 __NSSetI
objc[32735]: [0x7f91fd005048] ################ POOL 0x7f91fd005048
objc[32735]: [0x7f91fd005050] ################ POOL 0x7f91fd005050
objc[32735]: [0x7f91fd005058] ################ POOL 0x7f91fd005058
objc[32735]: ##############
复制代码
销毁一个@autoreleasepool
若是上面代码中最里面的@autoreleasepool退出以后再打印呢？
extern void _objc_autoreleasePoolPrint(void);
int main(int argc, char * argv[]) {
@autoreleasepool {
@autoreleasepool {
@autoreleasepool {
}
//打印的时候，最里面的@autoreleasepool已经退出了
_objc_autoreleasePoolPrint();
}
return UIApplicationMain(argc, argv, nil, NSStringFromClass([AppDelegate class]));
}
}
复制代码
输出为以下，只有两个哨兵(POOL)
objc[32812]: ##############
objc[32812]: AUTORELEASE POOLS for thread 0x1142b1d40
objc[32812]: 4 releases pending.
objc[32812]: [0x7fe86e800000] ................ PAGE (hot) (cold)
objc[32812]: [0x7fe86e800038] 0x600003edb0c0 __NSArrayI
objc[32812]: [0x7fe86e800040] 0x6000008dd680 __NSSetI
objc[32812]: [0x7fe86e800048] ################ POOL 0x7fe86e800048
objc[32812]: [0x7fe86e800050] ################ POOL 0x7fe86e800050
objc[32812]: ##############
复制代码
进一步说明了，
-
调用push方法会将一个
POOL_BOUNDARY入栈，而且返回其存放的内存地址 -
调用pop方法时传入一个
POOL_BOUNDARY的内存地址，会从最后一个入栈的对象开始发送release消息，直到遇到这个POOL_BOUNDARY
开头的问题
如今咱们回过头看文章开头的问题，应该很好回答了。
@interface ViewController ()
{
__weak NSString *string_weak;
}
@end
@implementation ViewController
- (void)viewDidLoad {
[super viewDidLoad];
// 场景一
// NSString *str = [NSString stringWithFormat:@"https://ityongzhen.github.io/"];
// string_weak = str;
// 场景二
// @autoreleasepool {
// NSString *str = [NSString stringWithFormat:@"https://ityongzhen.github.io/"];
// string_weak = str;
// }
//
// // 场景三
NSString *str = nil;
@autoreleasepool {
str = [NSString stringWithFormat:@"https://ityongzhen.github.io/"];
string_weak = str;
}
NSLog(@"string: %@ %s", string_weak,__func__);
}
- (void)viewWillAppear:(BOOL)animated{
[super viewWillAppear:animated];
NSLog(@"string: %@ %s", string_weak,__func__);
}
- (void)viewDidAppear:(BOOL)animated{
[super viewDidAppear:animated];
NSLog(@"string: %@ %s", string_weak,__func__);
}
复制代码
输出结果以下：
// 场景一
iOS定时器[24714:332118] string: https://ityongzhen.github.io/ -[ViewController viewDidLoad]
iOS定时器[24714:332118] string: https://ityongzhen.github.io/ -[ViewController viewWillAppear:]
iOS定时器[24714:332118] string: (null) -[ViewController viewDidAppear:]
场景二
iOS定时器[24676:331168] string: (null) -[ViewController viewDidLoad]
iOS定时器[24676:331168] string: (null) -[ViewController viewWillAppear:]
iOS定时器[24676:331168] string: (null) -[ViewController viewDidAppear:]
场景三
iOS定时器[24505:328544] string: https://ityongzhen.github.io/ -[ViewController viewDidLoad]
iOS定时器[24505:328544] string: (null) -[ViewController viewWillAppear:]
iOS定时器[24505:328544] string: (null) -[ViewController viewDidAppear:]
复制代码
场景一
当使用 [NSString stringWithFormat:@"https://ityongzhen.github.io/"] 建立一个对象时，这个对象的引用计数为 1 ，而且这个对象被系统自动添加到了当前的 autoreleasepool 中。当使用局部变量 str 指向这个对象时，这个对象的引用计数 +1 ，变成了 2 。由于在 ARC 下 NSString *str本质上就是 __strong NSString *str 。因此在 viewDidLoad 方法返回前，这个对象是一直存在的，且引用计数为 2 。而当viewDidLoad 方法返回时，局部变量 str 被回收，指向了 nil 。所以，其所指向对象的引用计数 -1 ，变成了 1 。
而在 viewWillAppear 方法中，咱们仍然能够打印出这个对象的值，在viewDidAppear方法中，这个值为空，这个就要牵扯到RunLoop的知识了。详解RunLoop之源码分析一文讲述了RunLoop的底层，这里说一下，咱们的iOS处理事件是以RunLoop一直循环执行的。viewDidLoad和viewWillAppear在同一个RunLoop循环中，因此在 viewWillAppear 方法中，咱们仍然能够打印出这个对象的值，可是viewDidLoad的时候，那个RunLoop循环已经执行完了，这个对象才被完全的释放。
场景二
当经过 [NSString stringWithFormat:@"https://ityongzhen.github.io/"] 建立一个对象时，这个对象的引用计数为 1 。而当使用局部变量 str 指向这个对象时，这个对象的引用计数 +1 ，变成了 2 。而出了当前做用域时，局部变量 str 变成了 nil ，因此其所指向对象的引用计数变成 1 。另外，咱们知道当出了 @autoreleasepool {}的做用域时，当前 autoreleasepool 被 drain ，其中的 autoreleased 对象被 release 。因此这个对象的引用计数变成了 0 ，对象最终被释放
场景三
当出了 @autoreleasepool {} 的做用域时，其中的 autoreleased 对象被 release ，对象的引用计数变成 1 。当出了局部变量 str 的做用域，即 viewDidLoad 方法返回时，str 指向了 nil ，其所指向对象的引用计数变成 0 ，对象最终被释放
注意点
前面说了注意str的长度不能过短是为何呢？
是由于若是str太短。例如
@interface ViewController ()
{
__weak NSString *string_weak;
}
@end
@implementation ViewController
- (void)viewDidLoad {
[super viewDidLoad];
// 场景一
// NSString *str = [NSString stringWithFormat:@"abc"];
// string_weak = str;
// 场景二
// @autoreleasepool {
// NSString *str = [NSString stringWithFormat:@"abc"];
// string_weak = str;
// }
//
// // 场景三
NSString *str = nil;
@autoreleasepool {
str = [NSString stringWithFormat:@"abc"];
string_weak = str;
}
NSLog(@"string: %@ %s", string_weak,__func__);
}
- (void)viewWillAppear:(BOOL)animated{
[super viewWillAppear:animated];
NSLog(@"string: %@ %s", string_weak,__func__);
}
- (void)viewDidAppear:(BOOL)animated{
[super viewDidAppear:animated];
NSLog(@"string: %@ %s", string_weak,__func__);
}
复制代码
结果以下：
// 场景一
iOS定时器[24714:332118] string: abc -[ViewController viewDidLoad]
iOS定时器[24714:332118] string: abc -[ViewController viewWillAppear:]
iOS定时器[24714:332118] string: abc -[ViewController viewDidAppear:]
场景二
iOS定时器[24676:331168] string: abc -[ViewController viewDidLoad]
iOS定时器[24676:331168] string: abc -[ViewController viewWillAppear:]
iOS定时器[24676:331168] string: abc -[ViewController viewDidAppear:]
场景三
iOS定时器[24505:328544] string: abc -[ViewController viewDidLoad]
iOS定时器[24505:328544] string: abc -[ViewController viewWillAppear:]
iOS定时器[24505:328544] string: abc -[ViewController viewDidAppear:]
复制代码
这是由于，字符串的abc采用的是Tagged Pointer技术，不是一个标准的OC对象。不存在说再堆上开辟空间存储对象什么的。关于Tagged Pointer能够参考这篇文章iOS中的引用计数,这里不作赘述。
总结
-
自动释放池的主要底层数据结构是：
__AtAutoreleasePool、AutoreleasePoolPage -
调用了
autorelease的对象最终都是经过AutoreleasePoolPage对象来管理的 -
每一个
AutoreleasePoolPage对象占用4096字节内存，除了用来存放它内部的成员变量，剩下的空间用来存放autorelease对象的地址 -
全部的
AutoreleasePoolPage对象经过双向链表的形式链接在一块儿 -
调用
push方法会将一个POOL_BOUNDARY入栈，而且返回其存放的内存地址 -
调用
pop方法时传入一个POOL_BOUNDARY的内存地址，会从最后一个入栈的对象开始发送release消息，直到遇到这个POOL_BOUNDARY -
id *next指向了下一个能存放autorelease对象地址的区域 -
iOS在主线程的
Runloop中注册了2个Observer- 第1个
Observer监听了kCFRunLoopEntry事件，会调用objc_autoreleasePoolPush() - 第2个
Observer- 监听了
kCFRunLoopBeforeWaiting事件，会调用objc_autoreleasePoolPop()、objc_autoreleasePoolPush() - 监听了
kCFRunLoopBeforeExit事件，会调用objc_autoreleasePoolPop()
- 监听了
- 第1个
-
在当次RunLoop将要结束的时候，调用
objc_autoreleasePoolPop()
参考资料
Objective-C Autorelease Pool 的实现原理
更多资料，欢迎关注我的公众号，不定时分享各类技术文章。
相关文章
- 1. iOS之autoreleasepool详解
- 2. AutoreleasePool
- 3. autoreleasepool
- 4. 深入解析 Autoreleasepool
- 5. iOS -- Autorelease & AutoreleasePool
- 6. AutoreleasePool的实现
- 7. Runloop和AutoreleasePool
- 8. iOS面试—二、autoreleasePool
- 9. iOS面试之AutoreleasePool
- 10. iOS | autoreleasePool的实现
- 更多相关文章...
- • 免费ARP详解 - TCP/IP教程
- • *.hbm.xml映射文件详解 - Hibernate教程
- • Flink 数据传输及反压详解
- • 为了进字节跳动，我精选了29道Java经典算法题，带详细讲解
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
欢迎关注本站公众号,获取更多信息
