ARC下,我们使用@autoreleasepool{}来使用一个AutoreleasePool
void main(int argc, char * argv[]) {
@autoreleasepool {
}
}
随后编译器将其改写成下面的样子(clang -rewrite-objc main.m):
报错 main.m:9:9: fatal error: 'UIKit/UIKit.h' file not found,
#import <UIKit/UIKit.h>
尴尬!换个命令 xcrun -sdk iphonesimulator clang -rewrite-objc main.m(指定模拟器/SDK)
如果报错 xcodebuild[3632:229732] [MT] PluginLoading: Required plug-in compatibility UUID E0A62D1F-3C18-4D74-BFE5-A4167D643966 for plug-in at path '~/Library/Application Support/Developer/Shared/Xcode/Plug-ins/CocoaPods.xcplugin' not present in DVTPlugInCompatibilityUUIDs
则Finder 前往这个地址,显示包内存在Info.plist文件的DVTPlugInCompatibilityUUIDs数组中添加一item,值为E0A62D1F-3C18-4D74-BFE5-A4167D643966
~>
int main(int argc, char * argv[]) {
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
}
}
我们写的@autoreleasepool{}变成了 @autoreleasepool 与 {}两部分,第一部分@autorelease被注释,很明显它的作用对于编译器只是一个标示。第二部分{}
__AtAutoreleasePool 是一结构体
struct __AtAutoreleasePool {
__AtAutoreleasePool() {atautoreleasepoolobj = objc_autoreleasePoolPush();}
~__AtAutoreleasePool() {objc_autoreleasePoolPop(atautoreleasepoolobj);}
void * atautoreleasepoolobj;
};
__AtAutoreleasePool __autoreleasepool; 这一句声明,多少有点C++11 中的trivial的身影(可是看到了结构体中的构造和析构函数,一脸懵逼)
构造函数与类名相同,没有返回值。析构函数与类名相同,前面加上~,没有返回值和参数,对象销毁时自动调用。
未定义构造函数,那么编译器会添加有一个无参的构造函数,而如果定义了构造函数,不会默认生成,如果你还想允许无参构造,就必须显式的声明一个
尽管有点诡异,但是构造函数和析构函数还在那摆着呢。以上代码等价于
void main(int argc, const char * argv[]) {
{
void * autoreleasepoolobj = objc_autoreleasePoolPush();
objc_autoreleasePoolPop(autoreleasepoolobj);
}
结构体会在初始化时调用 objc_autoreleasePoolPush() 方法,会在析构时(出作用域)调用 objc_autoreleasePoolPop 方法
@autoreleasepool 只是帮助我们少写了这两行代码而已,让代码看起来更美观。我们下面就要依据这两个方法,展开
void *objc_autoreleasePoolPush(void) {
return AutoreleasePoolPage::push();
}
void objc_autoreleasePoolPop(void *ctxt) {
AutoreleasePoolPage::pop(ctxt);
}
AutoreleasePoolPage 的静态方法push 和 pop,两个函数都是对AutoreleasePoolPage的简单封装
AutoreleasePoolPage is who?
AutoreleasePoolPage是一个C++实现的类
class AutoreleasePoolPage {
magic_t const magic;
id *next;
pthread_t const thread;
AutoreleasePoolPage * const parent;
AutoreleasePoolPage *child;
uint32_t const depth;
uint32_t hiwat;
};
1 magic 用于对当前 AutoreleasePoolPage 完整性的校验
2 AutoreleasePool是按线程一一对应的(结构中的thread指针指向当前线程)
3 AutoreleasePool(自动释放池)并没有单独的结构,而是由若干个AutoreleasePoolPage组合。每一个 AutoreleasePoolPage 的大小都是4096 字节, 前56 bit 用于存储 AutoreleasePoolPage 的成员变量,剩下的用来存储加入到自动释放池中的对象(autorelease对象的地址)
4 上面的next指针作为游标,指向栈顶最新add进来的autorelease对象的下一个位置
next 指向了下一个为空的内存地址,如果 next 指向的地址加入一个 object,它就会如下图所示移动到下一个为空的内存地址中
5 一个AutoreleasePoolPage的空间被占满时,会新建一个AutoreleasePoolPage对象,连接链表,后来的autorelease对象在新的page加入
6 AutoreleasePoolPage 是双向链表的形式连接起来的(parent 和 child 用来构造双向链表的指针)
7 begin() 和 end() 这两个类的实例方法获取一个AutoreleasePoolPage的存储autorelease对象地址的区域边界
到了这里,你可能想要知道 POOL_SENTINEL 到底是什么,还有它为什么在栈中?
#define POOL_SENTINEL nil
POOL_SENTINEL 只是 nil 的别名,是一个哨兵对象。
static inline void *push() {
return autoreleaseFast(POOL_SENTINEL);
}
static inline id *autoreleaseFast(id obj)
{
AutoreleasePoolPage *page = hotPage();
//有 hotPage 并且 hotPage 不满
if (page && !page->full()) {
//调用 page->add(obj) 方法将对象添加至 AutoreleasePoolPage 的栈中
return page->add(obj);
} else if (page) {//有 hotPage 并且hotPage 已满
return autoreleaseFullPage(obj, page);
} else {
//无 hotPage
return autoreleaseNoPage(obj);
}
}
1 objc_autoreleasePoolPush -> AutoreleasePoolPage::push --> autoreleaseFast(POOL_SENTINEL)
因此,调用objc_autoreleasePoolPush,最终调用autoreleaseFast 方法,并传入哨兵对象 POOL_SENTINEL
2 该函数分三种情况选择不同的代码执行(hotPage 可以理解为当前正在使用的 AutoreleasePoolPage)
将哨兵对象添加到hotPage中(page->add 添加对象),对函数整理简化
id *add(id obj) {
id *ret = next;
*next = obj;
next++;
return ret;
}
这个函数其实就是一个压栈的操作,将对象加入 AutoreleasePoolPage 然后移动栈顶的指针。
autoreleaseFast(POOL_SENTINEL),函数返回的是哨兵对象的地址
然后,顺便看下autoreleaseFullPage()与autoreleaseNoPage()函数(page->child指向下一页page)
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 方法添加对象
如果不存在 hotPage,就会调用 autoreleaseNoPage 方法初始化一个 AutoreleasePoolPage,从头开始构建双向链表,也就是说,新的 AutoreleasePoolPage 是没有 parent 指针的
static id *autoreleaseNoPage(id obj) {
AutoreleasePoolPage *page = new AutoreleasePoolPage(nil);
setHotPage(page);
if (obj != POOL_SENTINEL) {
//可见成员变量之上必然是哨兵对象,无论传入与否。来确保在 pop 调用的时候,不会出现异常
page->add(POOL_SENTINEL);
}
return page->add(obj);
}
综上,autoreleaseFast()将哨兵对象添加到hotpage中,并返回哨兵对象的地址
3 objc_autoreleasePoolPush之后,autorelease对象必然执行类似操作进栈,纷纷添加到page中,直到objc_autoreleasePoolPop()(参数对应push返回值,哨兵对象的地址)
static inline void pop(void *token) {
//获取哨兵对象所在page(首地址)
AutoreleasePoolPage *page = pageForPointer(token);
id *stop = (id *)token;
//释放本次push进的对象
page->releaseUntil(stop);
//根据当前页的不同状态 kill 掉不同 child 的页面
if (page->child) {
if (page->lessThanHalfFull()) {
page->child->kill();
} else if (page->child->child) {
page->child->child->kill();
}
}
}
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)取模,得到指针在page中的偏移量(因为所有的 AutoreleasePoolPage 在内存中都是对齐的)减去偏移量得到page的首地址,最后调用fastCheck() 用来检查此地址是不是一个 AutoreleasePoolPage(通过检查成员magic)
回到 pop函数,然后 page->releaseUntil(stop); 哨兵对象所在页page调用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);
}
这里,需要明白一点:
可能此次push进page的对象(指针)比较多,哨兵对象所在的page已不是hotpage
但是,由autoreleaseFullPage()可以看出,hotpage必然是哨兵对象所在的page的子节点(子子节点~)
找到当前hotpage,如果已空,通过parent指针遍历双向链表,找到不空的page作为hotpage(这个就是对应上面的情况,将hotpage清空,然后找到父节点继续,直到来到哨兵对象地址)
通过page的next指针, memset将内存的内容设置成 SCRIBBLE,然后使用 objc_release 释放对象,next指针必然前移。继续循环释放对象
每次进栈,add位置依据next指针指向,之后next指向后移。进栈依据next指针,出栈也是依据next指针。出栈之后,之后next指向前移。push可能用到多页page,释放必然也可能释放多页page,因此push进栈涉及到hotpage的变换,pop出栈也涉及到hotpage的切换。
这是一个不断出栈的过程,只要哨兵对象所在页page的next指针不指向此哨兵对象,循环继续
以上,就是源码分析。我们应该知道:
1 如果存在多个自动释放池,那么它们在page之间的界限就是哨兵对象
2 自动释放池的嵌套
@autoreleasepool {//pool 1
obj1 = xxx autorelease;
@autoreleasepool {//pool 2
__autoreleasing obj2 = xxx;
@autoreleasepool {//pool 3
obj3 = alloc;
}
}
}
它们在page中的位置,如下(假设同一个page)
next指针指向
pool 3哨兵对象 nil
obj2地址
pool 2哨兵对象 nil
obj1地址
pool 1哨兵对象 nil
加入释放池,也是依据代码顺序,加入到对应的哨兵对象之后。释放池废弃时,也是先依据代码顺序,先释放最内测的释放池。当然这仅仅是以一个page为例
我们之前说过,RunLoop每次循环会创建自动释放池,这个自动释放必然是很外侧的自动释放池,而我们手动创建的相对于该自动释放池是相对内侧的释放池,该自动释放池释放时,内侧的自动释放池s必然一同释放(循环)