iOS开发笔记（七）：深刻理解 Autorelease

时间  2019-12-06
标签 ios 开发 笔记 深刻 理解 autorelease 栏目 iOS 繁體版
原文   原文链接

Autorelease 机制是 iOS 开发者管理对象内存的好伙伴，MRC中，调用 [obj autorelease] 来延迟内存的释放是一件简单天然的事，ARC下，咱们甚至能够彻底不知道 Autorelease 就能管理好内存。而在这背后，objc 和编译器都帮咱们作了哪些事呢，它们是如何协做来正确管理内存的呢？刨根问底，一块儿来探究下黑幕背后的 Autorelease 机制。objective-c

1.Autoreleased 对象什么时候被释放

autorelease 本质上就是延迟调用 release，那 autoreleased 对象究竟会在何时释放呢？如下咱们来作一个实验。app

特别说明：在苹果一些新的硬件设备上，本实验的结果已经再也不成立，详细状况以下：框架

  • iPad 2less

  • iPad Air函数

  • iPad Air 2oop

  • iPad Propost

  • iPad Retina测试

  • iPhone 4sui

  • iPhone 5this

  • iPhone 5s

  • iPhone 6

  • iPhone 6 Plus

  • iPhone 6s

  • iPhone 6s Plus

    __weak NSString *string_weak_ = nil;
  - (void)viewDidLoad {
  	[super viewDidLoad];

  	// 场景 1
  	NSString *string = [NSString stringWithFormat:@"leichunfeng"];
  	string_weak_ = string;

  	// 场景 2
  //    @autoreleasepool {
  //        NSString *string = [NSString stringWithFormat:@"leichunfeng"];
  //        string_weak_ = string;
  //    }

  	// 场景 3
  //    NSString *string = nil;
  //    @autoreleasepool {
  //        string = [NSString stringWithFormat:@"leichunfeng"];
  //        string_weak_ = string;
  //    }

  	NSLog(@"string: %@", string_weak_);
  }

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

  - (void)viewDidAppear:(BOOL)animated {
  	[super viewDidAppear:animated];
  	NSLog(@"string: %@", string_weak_);
  }
复制代码

    让咱们一块儿来看看 console 输出：

    // 场景 1
  2015-05-30 10:32:20.837 AutoreleasePool[33876:1448343] string: leichunfeng
  2015-05-30 10:32:20.838 AutoreleasePool[33876:1448343] string: leichunfeng
  2015-05-30 10:32:20.845 AutoreleasePool[33876:1448343] string: (null)

  // 场景 2
  2015-05-30 10:32:50.548 AutoreleasePool[33915:1448912] string: (null)
  2015-05-30 10:32:50.549 AutoreleasePool[33915:1448912] string: (null)
  2015-05-30 10:32:50.555 AutoreleasePool[33915:1448912] string: (null)

  // 场景 3
  2015-05-30 10:33:07.075 AutoreleasePool[33984:1449418] string: leichunfeng
  2015-05-30 10:33:07.075 AutoreleasePool[33984:1449418] string: (null)
  2015-05-30 10:33:07.094 AutoreleasePool[33984:1449418] string: (null)
复制代码

分析

3 种场景下，咱们都经过 [NSString stringWithFormat:@"leichunfeng"] 建立了一个 autoreleased 对象，这是咱们实验的前提。而且，为了可以在 viewWillAppear 和 viewDidAppear 中继续访问这个对象，咱们使用了一个全局的 __weak 变量 string_weak_ 来指向它。由于 __weak 变量有一个特性就是它不会影响所指向对象的生命周期，这里咱们正是利用了这个特性。

场景 1

当使用 [NSString stringWithFormat:@"leichunfeng"] 建立一个对象时，这个对象的引用计数为 1，而且这个对象被系统自动添加到了当前的 autoreleasepool 中。当使用局部变量 string 指向这个对象时，这个对象的引用计数 +1 ，变成了 2。由于在 ARC 下 NSString *string 本质上就是 __strong NSString *string。因此在 viewDidLoad 方法返回前，这个对象是一直存在的，且引用计数为 2。而当 viewDidLoad 方法返回时，局部变量 string 被回收，指向了 nil。所以，其所指向对象的引用计数 -1，变成了 1。

而在 viewWillAppear 方法中，咱们仍然能够打印出这个对象的值，说明这个对象并无被释放。不是一直都说当函数返回的时候，函数内部产生的对象就会被释放的吗？前面咱们提到了，这个对象是一个 autoreleased 对象，autoreleased 对象是被添加到了当前最近的 autoreleasepool 中了，只有当这个 autoreleasepool 自身 drain 的时候，autoreleasepool 中的 autoreleased 对象才会被 release。

另外，咱们注意到当在 viewDidAppear 中再打印这个对象的时候，对象的值变成了 nil ，说明此时对象已经被释放了。所以，咱们能够大胆地猜想一下，这个对象必定是在 viewWillAppear 和 viewDidAppear 方法之间的某个时候被释放了，而且是因为它所在的 autoreleasepool 被 drain 的时候释放的。

场景 2

同理，当经过 [NSString stringWithFormat:@"leichunfeng"] 建立一个对象时，这个对象的引用计数为 1。而当使用局部变量 string 指向这个对象时，这个对象的引用计数 +1，变成了 2。而出了当前做用域时，局部变量 string 变成了 nil ，因此其所指向对象的引用计数变成 1。另外，咱们知道当出了 @autoreleasepool {} 的做用域时，当前 autoreleasepool 被 drain，其中的 autoreleased 对象被 release。因此这个对象的引用计数变成了 0，对象最终被释放。

场景 3

同理，当出了 @autoreleasepool {} 的做用域时，其中的 autoreleased 对象被 release，对象的引用计数变成 1。当出了局部变量 string 的做用域，即 viewDidLoad 方法返回时，string 指向了 nil，其所指向对象的引用计数变成 0，对象最终被释放。

总结

理解在这 3 种场景下，autoreleased 对象何时释放对咱们理解 Objective-C 的内存管理机制很是有帮助。其中，场景 1 出现得最多，就是不须要咱们手动添加 @autoreleasepool {} 的状况，直接使用系统维护的 autoreleasepool ；场景 2 就是须要咱们手动添加 @autoreleasepool {} 的状况，手动干预 autoreleased 对象的释放时机；场景 3 是为了区别场景 2 而引入的，在这种场景下并不能达到出了 @autoreleasepool {} 的做用域时 autoreleased 对象被释放的目的。

注意：不要混淆 autoreleasepool 与 @autoreleasepool {}

2.AutoreleasePool 与 RunLoop

首先咱们明确什么对象会自动加入 autoreleasepool ：

  • MRC 下须要对象调用 autorelease 才会入池, ARC 下能够经过 __autoreleasing 修饰符，不然的话看方法名，经过调用 alloc/new/copy/mutablecopy 之外的方法取得的对象，编译器帮咱们自动加入 autoreleasepool (使用 alloc/new/copy/mutablecopy 方法进行初始化时，由系统管理对象，在适当的位置 release，不加入 autoreleasepool )。
  • 使用 array 会自动将返回对象注册到 autoreleasepool。
  • __weak 修饰的对象，为了保证在引用时不被废弃，会注册到 autoreleasepool 中。
  • id 的指针或对象的指针，在没有显式指定时会被注册到 autoreleasepool 中。

前面一节咱们讲到，autoreleased 对象会被加到最近的 autoreleasepool 中，只有当这个 autoreleasepool 自身 drain 的时候，autoreleasepool 中的 autoreleased 对象才会被 release (retainCount = 0 时对象释放)。

那么 autoreleasepool 是在何时释放的呢。我的以为有如下两种状况：

  • MRC 下显式的调用 drain 方法。对于获取不到的 NSAutoreleasePool 对象没法操做，不是咱们讨论的重点。

  • 在 runloop 开始时，都会隐式建立一个 autoreleasepool，并会在 runloop 结束时把前面建立的 autoreleasepool drain。

    AutoreleasePool 与 RunLoop

    程序运行 -> 开启事件循环 -> 发生触摸事件 -> 建立自动释放池 -> 处理触摸事件 -> 事件对象加入自动释放池 -> 一次事件循环结束，销毁自动释放池

    至于 runloop 什么时候结束就没法肯定了。

    上面场景一中，因为调用的非 alloc/new/copy/mutablecopy 方法取得对象，这个对象就自动被系统添加到了由主线程的 NSRunLoop 对象建立的 autoreleasepool 中，并在这个 autoreleasepool 被 drain 时获得释放。然而 runloop 什么时候结束没法肯定，咱们也不能显式的调用 drain 方法，那有没有好的解决办法呢？幸运的是能够。咱们可使用 NSAutoreleasepool 或 @autoreleasepool {}将对象加入到咱们建立的 autorelasepool 中，手动干预释放 (如场景二)。

    之因此能够这么作确定和它的实现原理有关，下面咱们具体讨论它的结构，相信你们看完确定能有本身的结论。

3.AutoreleasePool 的实现

3.1 从 main 函数开始

main 函数能够说是在整个 iOS 开发中很是不起眼的一个函数，但倒是整个 iOS 应用的入口。

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

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

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

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

3.2 @autoreleasepool

@autoreleasepool 究竟是什么？咱们在命令行中使用使用如下命令让编译器从新改写这个文件：

clang -x objective-c -rewrite-objc -isysroot /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator.sdk main.m
复制代码

在生成了一大堆警告以后，当前目录下多了一个 main.cpp 文件。在文件的最后，咱们能够看到以下代码：

int main(int argc, char * argv[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 
    	return UIApplicationMain(argc, argv, __null, NSStringFromClass(((Class (*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("AppDelegate"), sel_registerName("class"))));
    }
}
复制代码

在这个文件中，有一个很是奇怪的 __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 只是帮助咱们少写了这两行代码而已，让代码看起来更美观。

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

4.1 AutoreleasePoolPage 的结构

AutoreleasePoolPage 是一个 C++ 中的类：

AutoreleasePoolPage

它在 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 是以双向链表的形式链接起来的：

AutoreleasePoolPage-linked-list

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

自动释放池中的栈

若是咱们的一个 AutoreleasePoolPage 被初始化在内存的 0x100816000 ~ 0x100817000 中，它在内存中的结构以下：

page-in-memory

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

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

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

after-insert-to-page

关于 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：

pop-stack

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

4.3 objc_autoreleasePoolPop 方法

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

void objc_autoreleasePoolPop(void *ctxt) {
    AutoreleasePoolPage::pop(ctxt);
}
复制代码

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

咱们通常都会在这个方法中传入一个哨兵对象 POOL_SENTINEL，以下图同样释放对象：

pop-stack

对 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 方法，将字符串加入自动释放池：

breakpoint-main

当代码运行到这里时，经过 lldb 打印出当前 hotPage 中的栈内容：

print-pool-content

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

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

pop-string

再次打印当前 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 方法

    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);
}
复制代码

4.4 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 方法的实现，这里就不会多说了。

4.5 小结

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

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

5.拾遗

5.1 NSAutoreleasePool

NSAutoreleasePool 是 Cocoa 用来支持引用计数内存管理机制的类，当一个 autorelease pool 被 drain 的时候会对 pool 里的对象发送一条 release 的消息。(不能在 ARC 下使用)

使用方法以下：

NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
NSArray *array = [[[NSArray alloc] init] autorelease];
[pool drain];
复制代码

5.2 AutoreleasePool 与线程

每个线程 (包括主线程) 都有一个 autoreleasepool 栈。当一个新的池子被建立的时候，push 进栈，当池子被释放内存时，pop 出栈。对象调用 autorelease 方法进入栈顶的池子中。当线程结束的时候，它会自动地销毁掉全部跟它有关联的池子。

线程中的自动释放池栈

5.3 容器的 block 版本的枚举器

使用容器的 block 版本的枚举器时，内部会自动添加一个 autoreleasepool：

[array enumerateObjectsUsingBlock:^(id obj, NSUInteger idx, BOOL *stop) {
// 这里被一个局部@autoreleasepool包围着
}];
复制代码

固然，在普通 for 循环和 for in 循环中没有，因此，仍是新版的 block 版本枚举器更加方便。for 循环中遍历产生大量 autorelease 变量时，就须要手加局部 autoreleasepool 咯。

5.4 何时用 AutoreleasePool

  • 写基于命令行的程序时，就是没有 UI 框架时，如 AppKit 等 Cocoa 框架。
  • 写循环，循环里面包含了大量临时建立的对象。
  • 建立了新的线程。
  • 长时间在后台运行的任务。

5.5 子线程默认不会开启 Runloop，那出现 Autorelease 对象如何处理？不手动处理会内存泄漏吗？

这一点请参考does NSThread create autoreleasepool automaticly now? 或 各个线程 Autorelease 对象的内存管理

6.参考

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程