iOS内存管理(5)-autorelease原理和autorelease和runloop的结合使用

内存管理之中autorelease部分是相当重要的,虽然现在都是ARC的时代了,我们还是要尽量去理解每一个原理,这对于我们理解代码的实现和原理是有很大的帮助的.MRC中，调用[obj autorelease]来延迟内存的释放是一件简单自然的事，ARC下，我们甚至可以完全不知道Autorelease就能管理好内存。那么接下来我们就理解下autorelease的原理.

1. autorelease原理

autorelease原理是什么呢?我们可以通过一行代码来观看 :

@autoreleasepool {
    Person *p = [[[Person alloc] init] autorelease];
}

这个是很简单的MRC的代码,我们可以通过把OC代码转换成C++代码:

 {
    __AtAutoreleasePool __autoreleasepool;
    MJPerson *person = ((MJPerson *(*)(id, SEL))(void *)objc_msgSend)((id)((MJPerson *(*)(id, SEL))(void *)objc_msgSend)((id)((MJPerson *(*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("MJPerson"), sel_registerName("alloc")), sel_registerName("init")), sel_registerName("autorelease"));
 }

上边的代码看起来还是有一些繁琐,我们再把C++代码简化:

{
    __AtAutoreleasePool __autoreleasepool;
   MJPerson *person = [[[MJPerson alloc] init] autorelease];
 }

最后简化成的代码中的__AtAutoreleasePool是什么? __AtAutoreleasePool是一个结构体

struct __AtAutoreleasePool{
    __AtAutoreleasePool{//构造函数,在创建结构体变量的时候调用
        atautoreleasepoolobj = objc_autoreleasePoolPush();
    }
    __AtAutoreleasePool{//析构函数,在结构体销毁的时候调用
        objc_atautoreleasePoolPop(atautoreleasepoolobj);
    }
    void * atautoreleasepoolobj;
};

在这个结构体中第一次函数是一个C++的构造函数,objc_autoreleasePoolPush();这个方法会在创建结构体变量的时候调用.
第二个函数是一个C++的析构函数,objc_atautoreleasePoolPop(atautoreleasepoolobj);这个方法会在结构体销毁的时候调用.
所以上面的代码可以转化为:

{
  atautoreleasepoolobj = objc_autoreleasePoolPush();
  Person *person = [[[Person alloc] init] autorelease];
  objc_autoreleasePoolPop(atautoreleasepoolobj);
}

一. AutoreleasePoolPage的结构

自动释放池的主要底层数据结构是：__AtAutoreleasePool、AutoreleasePoolPage,来看一下objc_autoreleasePoolPush 和 objc_autoreleasePoolPop 的实现：

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

上面的方法看上去是对 AutoreleasePoolPage 对应静态方法 push 和 pop 的封装.调用了autorelease的对象最终都是通过AutoreleasePoolPage对象来管理的.
AutoreleasePoolPage 是一个 C++ 中的类，它在 NSObject.mm 中的定义是这样的：

class AutoreleasePoolPage
{
    magic_t const magic;
    id *next;
    pthread const thread;
    AutoreleasePoolPage *const parent;
    AutoreleasePoolPage *child;
    uint32_t const depth;
    uint32_t hiwat;
}

①. magic 用于对当前 AutoreleasePoolPage 完整性的校验.
②. thread 保存了当前页所在的线程.

每个AutoreleasePoolPage对象占用4096字节内存，除了用来存放它内部的成员变量，剩下的空间用来存放autorelease对象的地址.

//源码中的代码是这样的
#define I386_PGBYTES 4096
#define PAGE_SIZE I386_PGBYTES

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

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

iOS内存管理(5)-autorelease原理和autorelease和runloop的结合使用_第1张图片

autoreleasePool的双向链表.png

在自动释放池中是存在自动释放池中的栈,被初始化在0x1000~0x2000.其中有56bit用于存储AutoreleasePoolPage的成员变量,剩下的 0x1038 ~ 0x2000 都是用来存储加入到自动释放池中的对象.begin() 和 end() 这两个类的实例方法帮助我们快速获取0x1038 ~ 0x2000 这一范围的边界地址.

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

iOS内存管理(5)-autorelease原理和autorelease和runloop的结合使用_第2张图片

next指针的原理.png

autoreleasePool的双向链表的执行步骤是:

调用push方法会将一个POOL_BOUNDARY入栈，并且返回其存放的内存地址，即返回给atautoreleasepoolobj。
调用pop方法时传入一个POOL_BOUNDARY的内存地址，会从最后一个入栈的对象开始发送release消息，直到遇到这个POOL_BOUNDARY.
id *next指针作为游标指向栈顶最新add进来的autorelease对象的下一个位置.
一个AutoreleasePoolPage的空间被占满时，会新建一个AutoreleasePoolPage对象，连接链表，后来的autorelease对象在新的page加入.

⑤. 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();
        objc_autoreleasePoolPop(atautoreleasepoolobj);
    }
    return 0;
}

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

iOS内存管理(5)-autorelease原理和autorelease和runloop的结合使用_第3张图片

Autoreleasepool的原理.png

objc_autoreleasePoolPush的返回值正是这个哨兵对象的地址，objc_autoreleasePoolPop(哨兵对象)作为入参，于是：

根据传入的哨兵对象地址找到哨兵对象所处的page.
在当前page中，将晚于哨兵对象插入的所有autorelease对象都发送一次 release消息，并向回移动next指针到正确位置.
补充2：从最新加入的对象一直向前清理，可以向前跨越若干个page，直到哨兵所在的page.

A. 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 (正在使用的AutoreleasePoolPage)并且当前 page 不满.
    ·调用 page->add(obj) 方法将对象添加至 AutoreleasePoolPage 的栈中.
②.有 hotPage 并且当前 page 已满.
    ·调用 autoreleaseFullPage初始化一个新的页.
    ·调用 page->add(obj) 方法将对象添加至 AutoreleasePoolPage的栈中.
③. 无 hotPage
    ·调用 autoreleaseNoPage 创建一个 hotPage.
    ·调用 page->add(obj) 方法将对象添加至 AutoreleasePoolPage的栈中.
④. 最后的都会调用 page->add(obj) 将对象添加到自动释放池中。

a. page->add 添加对象

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

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

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

b. 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 方法添加对象。

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

B. objc_autoreleasePoolPop 方法

同样，回顾一下上面提到的 objc_autoreleasePoolPop 方法：

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

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 方法.

a.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。

b. 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释放对象。

c. 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是什么样子的?

extern void _objc_autoreleasePoolPrint(void);

int main(int argc, const char * argv[]) {
    @autoreleasepool { //  r1 = push()
        
        Person *p1 = [[[Person alloc] init] autorelease];
        Person *p2 = [[[Person alloc] init] autorelease];
        
        @autoreleasepool { // r2 = push()
            for (int i = 0; i < 5; i++) {
                Person *p3 = [[[Person alloc] init] autorelease];
            }
            
            @autoreleasepool { // r3 = push()
                Person *p4 = [[[Person alloc] init] autorelease];
                _objc_autoreleasePoolPrint();
            } // pop(r3)
        } // pop(r2)
    } // pop(r1)
    return 0;
}

iOS内存管理(5)-autorelease原理和autorelease和runloop的结合使用_第4张图片

打印输出结果.png

因为只打印了一个PAGE，所以说明他们是在同一个AutoreleasePoolPage，只是每次一个新的autoreleasepool，都会插入一个POOL_BOUNDARY。

每次释放对象时，都是从后往前释放，直到遇到POOL_BOUNDARY为止。

那如果对象特别多又是什么样子的呢?

extern void _objc_autoreleasePoolPrint(void);

int main(int argc, const char * argv[]) {
    @autoreleasepool { //  r1 = push()
        
        Person *p1 = [[[Person alloc] init] autorelease];
        Person *p2 = [[[Person alloc] init] autorelease];
        
        @autoreleasepool { // r2 = push()
            for (int i = 0; i < 5; i++) {
                Person *p3 = [[[Person alloc] init] autorelease];
            }
            
            @autoreleasepool { // r3 = push()
                Person *p4 = [[[Person alloc] init] autorelease];
                _objc_autoreleasePoolPrint();
            } // pop(r3)
        } // pop(r2)
    } // pop(r1)
    return 0;
}

iOS内存管理(5)-autorelease原理和autorelease和runloop的结合使用_第5张图片

打印结果第一页.png

iOS内存管理(5)-autorelease原理和autorelease和runloop的结合使用_第6张图片

打印结果第二页.png

iOS内存管理(5)-autorelease原理和autorelease和runloop的结合使用_第7张图片

打印结果第三页.png

2. autorelease和runloop的结合使用

MRC的autorelease对象在什么时机会被调用release?

- (void)viewDidLoad {
    [super viewDidLoad];
    
    // 这个Person什么时候调用release，是由RunLoop来控制的
    // 它可能是在某次RunLoop循环中，RunLoop休眠之前调用了release
    MJPerson *person = [[[MJPerson alloc] init] autorelease];
    NSLog(@"%s", __func__);
}

- (void)viewWillAppear:(BOOL)animated
{
    [super viewWillAppear:animated];
    
    NSLog(@"%s", __func__);
}

- (void)viewDidAppear:(BOOL)animated
{
    [super viewDidAppear:animated];
    
    NSLog(@"%s", __func__);
}

打印结果.png

iOS在主线程的Runloop中注册了2个Observer

第1个Observer监听了kCFRunLoopEntry事件，会调用objc_autoreleasePoolPush().

第2个Observer:

监听了kCFRunLoopBeforeWaiting事件，会调用objc_autoreleasePoolPop()、objc_autoreleasePoolPush()

监听了kCFRunLoopBeforeExit事件，会调用objc_autoreleasePoolPop().

在ARC中方法里有局部对象，出了方法后会立即释放吗?

- (void)viewDidLoad {
    [super viewDidLoad];
    
    Person *person = [[Person alloc] init];
    NSLog(@"%s", __func__);
}

- (void)viewWillAppear:(BOOL)animated {
    [super viewWillAppear:animated];
    
    NSLog(@"%s", __func__);
}

- (void)viewDidAppear:(BOOL)animated {
    [super viewDidAppear:animated];
    
    NSLog(@"%s", __func__);
}

打印结果.png

通过打印结果可知，当person对象出了其作用域后就销毁，即系统会在它出作用域的时候，自动调用其release方法。

autoreleasePool 在何时被释放？

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 了。

                            想了解更多iOS学习知识请联系:QQ(814299221)

iOS内存管理(5)-autorelease原理和autorelease和runloop的结合使用

1. autorelease原理

一. AutoreleasePoolPage的结构

二. 代码分析

2. autorelease和runloop的结合使用

你可能感兴趣的:(iOS内存管理(5)-autorelease原理和autorelease和runloop的结合使用)