【iOS】autoreleasepool

来说一下最近在了解的autoreleasepool吧,我们可能平时书写过许多脑残代码,其有很多的缺陷但是我们可能当时学的比较浅就也不太了解,就像下面这样的:

for (int i = 0; i < 1000000; i++) {
    NSNumber *num = [NSNumber numberWithInt:i];
}

一、@autoreleasepool{}

我们平时创建一个main函数的代码的时候,就会发现其中有一个这个东西@autoreleasepool{},使用clang编译之后:@autoreleasepool{...}被编译成了{__AtAutoreleasePool __autoreleasepool; ... }

这个__AtAutoreleasePool到底是什么?

它其实是一个结构体,在创建__AtAutoreleasePool结构体变量的时候调用了objc_autoreleasePoolPush(void),销毁的时候会调动objc_autoreleasePoolPop(void *),即其构造函数和析构函数,所以我们可以看出其其实是一个C++封装的自动释放池变量,会将@autoreleasepool{…}中{}中的内容添加到自动释放池中,方便内存管理。

但是它在main这个函数中好像感觉并没有什么用,因为程序结束了那么内存不也就被释放了,那这里为什么要加@autoreleasepool{}

技术上是可行的,去掉main函数中的@autoreleasepool{}并没有什么关系,但是为了严谨,为了使UIApplicationMin创建出来的自动释放对象有自动释放池可添加,并能在自动释放池结束的时候释放对象而不是依赖操作系统的回收,所以加上@autoreleasepool{},可以把它理解为最外层才触发释放机制的自动释放池。

extern "C" __declspec(dllimport) void * objc_autoreleasePoolPush(void);
extern "C" __declspec(dllimport) void objc_autoreleasePoolPop(void *);

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

所以我们平时在ARC环境下写的@autoreleasepool{}它其实就是自动释放池创建和释放的简单使用。

【iOS】autoreleasepool_第1张图片

它会在{的时候创建自动释放池,在}的时候销毁自动释放池并发出release通知,让其中的变量自己进行release操作。

二、AutoreleasePoolPage

从上边的__AtAutoreleasePool我们可以看到这两种方法objc_autoreleasePoolPushobjc_autoreleasePoolPop,但是这究竟是什么呢?

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

我们可以看出这里又引入了新的类AutoreleasePoolPage,其相关源码如下:

class AutoreleasePoolPage {
    magic_t const magic;//AutoreleasePoolPage 完整性校验
    id *next;//下一个存放autorelease对象的地址
    pthread_t const thread; //AutoreleasePoolPage 所在的线程
    AutoreleasePoolPage * const parent;//父节点
    AutoreleasePoolPage *child;//子节点
    uint32_t const depth;//深度,也可以理解为当前page在链表中的位置
    uint32_t hiwat;
}

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

#define I386_PGBYTES 4096
#define PAGE_SIZE I386_PGBYTES

所以我们从上述的源码可以看出,自动释放池其实就是一个由AutoreleasePoolPage构成的双向链表,其结构中的childparent分别指向其前趋和后继。

【iOS】autoreleasepool_第2张图片

单个AutoreleasePoolPage结构如下:
【iOS】autoreleasepool_第3张图片

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

  • 该结构体的第一个成员变量是magic,我们在isa中也学习过,isa中是分判对象是否未完成初始化,在这里也一样,用来检查这个节点是否已经被初始化了。
  • begin()end()这两个类的实例方法帮助我们快速获取 0x100816038 ~ 0x100817000 这一范围的边界地址。
  • next指向下一个为空的内存地址,如果next指向的地址加入一个object,它就会如下图所示移动到下一个为空的内存地址中,就像栈顶指针一样。
  • thread保存了当前页所在的线程。
  • depth表示page的深度,首次为0,每个page的大小都是4096字节(16进制0x1000),每次初始化一个pagedepth都加一。
  • POOL_SENTINEL就是哨兵对象,它只是nil的别名,用于分隔AutoreleasepoolPOOL_BOUNDARY直译过来就是POOL的边界。它的作用是隔开page中的对象。因为并不是每次pushpop之间存进的对象都刚好占满一个page,可能会不满,可能会超过,因此这个POOL_BOUNDARY帮助我们分隔每个@autoreleasepool块之间的对象。也就是说这个page可能存储很多个@autoreleasepool块的对象,使用POOL_BOUNDARY来隔开每个@autoreleasepool块的对象。
#define POOL_SENTINEL nil

如果向上述刚初始化的page添加对象时,就会添加在next的指向处,next再向后移一位。
【iOS】autoreleasepool_第4张图片

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

int main(int argc, const char * argv[]) {
    {
    	//这里的 atautoreleasepoolobj 就是一个 POOL_SENTINEL
        void * atautoreleasepoolobj = objc_autoreleasePoolPush();
        
        // do whatever you want
        
        objc_autoreleasePoolPop(atautoreleasepoolobj);
    }
    return 0;
}

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

【iOS】autoreleasepool_第5张图片

这也是autoreleasepool能准确释放其中对象的原因:在该autoreleasepool push的时候会返回一个哨兵对象(POOL_SENTINEL)的地址,并将它给pop,那么这个pop就知道在执行pop释放的时候释放到这个哨兵对象(POOL_SENTINEL)处就可以停止了,而这其中释放的内容就正好是自动释放池中的对象。

1.objc_autoreleasePoolPush方法:

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

这里调用了AutoreleasePoolPage::push()方法:

static inline void *push() 
{
    id *dest;
    // POOL_BOUNDARY就是nil
    // 首先将一个哨兵对象插入到栈顶
    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;
}

其中调用了autoreleaseFast方法,hotPage指的是当前正在使用的AutoreleasePoolPage

static inline id *autoreleaseFast(id obj)
{
   AutoreleasePoolPage *page = hotPage();
   if (page && !page->full()) {//有 hotPage 并且当前 page 不满,将object加入当前栈中
       return page->add(obj);
   } else if (page) {//有hotPage 但当前page已满,找未满页或创建新页,将object添加到新页中
       return autoreleaseFullPage(obj, page);
   } else {//无hotPage,创建hotPage,加入其中
       return autoreleaseNoPage(obj);
   }
}

1.1 有hotPage并且当前page不满,直接调用page->add(obj)将对象添加到自动释放池中。

// 这其实就是一个压栈操作,将对象加入AutoreleasePoolPage,然后移动栈顶指针
id *add(id obj) {
    id *ret = next;
    *next = obj;
    next++;
    return ret;
}

1.2 有hotPage但当前page已满,找未满页或创建新页,将object添加到新页中autoreleaseFullPage (当前page满的时候调用):

static id *autoreleaseFullPage(id obj, AutoreleasePoolPage *page) {
//一直遍历,直到找到一个未满的 AutoreleasePoolPage,如果找到最后还没找到,就新建一个 AutoreleasePoolPage
    do {
        if (page->child) 
        	page = page->child;
        else page = new AutoreleasePoolPage(page);
    } while (page->full());
	
	//将找到的,或者构建的page作为hotPage,然后将obj加入
    setHotPage(page);
    return page->add(obj);
}

1.3 无hotPage,创建hotPage,加入其中:
这个时候,由于内存中没AutoreleasePoolPage,就要从头开始构建这个自动释放池的双向链表,那么当前页表作为第一张页表,是没有parent指针的。并且我们在第一次创建page时其首位都是要加POOL_SENTINEL标识的,方便让page知道在哪就结束了。

static id *autoreleaseNoPage(id obj) {
    AutoreleasePoolPage *page = new AutoreleasePoolPage(nil); // 创建AutoreleasePoolPage
    setHotPage(page); // 设置page为当前页
 
    if (obj != POOL_SENTINEL) { // 加POOL_SENTINEL哨兵
        page->add(POOL_SENTINEL);
    }
 
    return page->add(obj); // 将obj加入
}

autorelease方法

我们现在再想,它dest = autoreleaseFast(POOL_BOUNDARY);操作传递的是POOL_BOUNDARY变量,并没有传对象,那么到底是怎么存入进去的呢?

通过调试查看汇编发现它其实调用的是objc_retainAutorelease方法,之后层层调用发现调用的是autorelease方法:

static inline id autorelease(id obj)
{
    printf("static inline id autorelease%p\n", obj);
    assert(obj);
    assert(!obj->isTaggedPointer());
    id *dest __unused = autoreleaseFast(obj);
    assert(!dest  ||  dest == EMPTY_POOL_PLACEHOLDER  ||  *dest == obj);
    return obj;
}

2.objc_autoreleasePoolPop方法:

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

我们一般都会在这个方法中传入一个哨兵对象POOL_SENTINEL,方便释放,如下图一样释放对象:
【iOS】autoreleasepool_第6张图片

其调用的pop方法如下:

static inline void pop(void *token) {
    AutoreleasePoolPage *page = pageForPointer(token);//使用 pageForPointer 获取当前 token 所在的 AutoreleasePoolPage
    id *stop = (id *)token;

    page->releaseUntil(stop);//调用 releaseUntil 方法释放栈中的对象,直到 stop 位置,stop就是传递的参数,一般为哨兵对象

	//调用 child 的 kill 方法,系统根据当前页的不同状态kill掉不同child的页面
	//releaseUntil把page里的对象进行了释放,但是page本身也会占据很多空间,所以要通过kill()来处理,释放空间
    if (page->child) {
        if (page->lessThanHalfFull()) { // 当前page小于一半满
            page->child->kill(); // 把当前页的孩子杀掉
        } else if (page->child->child) { // 否则,留下一个孩子,从孙子开始杀
            page->child->child->kill();
        }
    }
}

Apple假设,当前page一半都没满,说明剩余的page空间已经暂时够了,把多余的child page就可以全kill掉,释放空间,如果超过一半,就认为下一页page还有存在的必要,说不定添加的对象太多就能用的到,所以kill掉孙子page,有个儿子page就暂时够了。

token

  • oken是指向该poolPOOL_BOUNDARY指针
  • token的本质就是指向哨兵对象的指针,存储着每次push时插入的POOL_BOUNDARY的地址
  • 只有第一次push的时候会在page中插入一个POOL_BOUNDARY【或者page满了,或者没有hotPage需要使用新的page了】,并不是page的开头都一定是POOL_BOUNDARY

2.1 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(); // 检查当前的result是不是一个AutoreleasePoolPage

    return result;
}

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

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

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

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

2.2 releaseUntil 释放对象:

releaseUntil方法的实现如下:

void releaseUntil(id *stop) {
    while (this->next != stop) { // 不等于stop就继续pop
        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)); // 将内存内容标记为SCRIBBLE
        page->protect();

        if (obj != POOL_SENTINEL) { // 该对象不为标识POOL_SENTINEL,就释放对象
            objc_release(obj);
        }
    }

    setHotPage(this);
}

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

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

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

void kill() {
    AutoreleasePoolPage *page = this; // 获取当前页
    while (page->child) page = page->child; // child存在就一直往下找,直到找到一个不存在的

    AutoreleasePoolPage *deathptr;
    do {
        deathptr = page;
        page = page->parent;
        if (page) {
            page->unprotect();
            page->child = nil; // 将其child指向置nil,防止出现悬垂指针
            page->protect();
        }
        delete deathptr; // 删除
    } while (deathptr != this); // 直到this处停止
}

3.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;
}

三、开头问题的解答

看到这里你是否明白了开篇所说的问题所在?当一次运行循环结束之前,也就是autoreleasepool释放autorelease对象之前,autoreleasepool的内存一直在增加,APP会出现内存峰值,卡顿,甚至会被系统强制关闭造成crash。

所以加上@autoreleasepool保证每次循环生成的autorelease对象及时的释放才能避免上述问题:

for (int i = 0; i < 1000000; i++) {
   @autoreleasepool {
          NSNumber *num = [NSNumber numberWithInt:i];
          NSLog(@"%@", num);
   }
}

另外@autoreleasepool还有延迟释放,使对象超出函数作用域存在等用处。

四、总结

总的来说,autoreleasepool就是一个双向链表,链表中的每个节点是一个栈,栈中保存了指向autoreleasepool的指针并且其中加入了需要自动释放池管理的对象,所以在autoreleasepool中的所有对象引用计数都会+1,一旦出了autoreleasepool,没有指针指向对象,对象的引用计数就会-1,ARC下,xcode会为代码自动添加 autoreleasepool

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

关于哨兵对象(POOL_BOUNDARY)和next指针:

next指针只有一个,永远指向下一个能存放autoreleasepool的地址,而哨兵对象可以有很多个,每个autoreleasePool都对应一个哨兵对象,标示这个autoreleasePool对象从哪里开始存。

next和child:
next指向下一个能存放object对象的地址,child是autoreleasePoolPage的参数,指向下一个page。

autoreleasePoolPage与RunLoop的关系:

【iOS】autoreleasepool_第7张图片
RunLoop和AutoReleasePool是通过线程的方式一一对应的
在非手动添加Autorelease pool下,Autorelease对象是在当前runloop进入休眠等待前被释放的
当一个runloop在不停的循环工作,那么runloop每一次循环必定会经过BeforeWaiting(准备进入休眠):而去BeforeWaiting(准备进入休眠) 时会调用_objc_autoreleasePoolPop()和 _objc_autoreleasePoolPush()释放旧的池并创建新池,那么这两个方法来销毁要释放的对象,所以我们根本不需要担心Autorelease的内存管理问题。

RunLoop创建和释放自动释放池的时机:

在进入RunLoop时,创建一个AutoReleasePool。
在准备休眠的时候,释放旧的AutoReleasePool,再新建一个AutoReleasePool。
在RunLoop退出时,释放AutoReleasePool。

保存autoreleasePoolPage的双向链表只有一个么?也就是所有线程的autoreleasePoolPage都保存在一个链表中,还是每个线程保存一个自己的链表?并且链表头也就是链表的入口位置是保存在哪里呢?谁来控制呢?

一个线程有自己单独autoreleasePool链表,也有可能没有链表。链表的hotPage存储在TLS中,因为链表是双向的,通过hotpage就可以找到表头和表尾,不需要再单独存储表头。

需要自己手动添加autoreleasepool的情况

  • 编写的不是基于UI框架的程序,例如命令行工具;
  • 通过循环方式创建大量临时对象;
  • 使用非Cocoa程序创建的子线程;

你可能感兴趣的:(ios)