一、Autoreleasepool
自动释放池，统一管理内部的局部变量。
autorelease就是将对象放入到对应的autoreleasepool中，当autoreleasepool作用域解决的时候，会将内部的变量全部进行一次release操作
二、main函数中具有一个全局的autoreleasepool
main函数中我们的主程序入口UIApplicationMain是被包裹再autoreleasepool内部的，而UIApplicationMain会开启RunLoop导致程序正常情况下会持续运行，不会退出，也就是autoreleasepool的作用域一直存在。那么里面的对象是如何被销毁的呢
三、源码分析
int main(int argc, char * argv[]) {
@autoreleasepool {
//UIApplicationMain 内部开启的引用循环
return UIApplicationMain(argc, argv, nil, NSStringFromClass([AppDelegate class]));
} // 循环不结束，不会进入次处，autoreleasepool 不会被释放才对
}
在命令行中编译main.m文件
xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc main.m
通过上面的命令会得到一个C++的文件
int main(int argc, char * argv[]) {
NSString * appDelegateClassName;
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
appDelegateClassName = NSStringFromClass(((Class (*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("AppDelegate"), sel_registerName("class")));
}
return UIApplicationMain(argc, argv, __null, appDelegateClassName);
}
通过源码发现
之前OC中的@autoreleasepool {}变成了
{
__AtAutoreleasePool __autoreleasepool;
......
}
__AtAutoreleasePool的内部结构是
struct __AtAutoreleasePool {
// 这个结构内部只有两个函数，一个是构造函数，一个是析构函数
__AtAutoreleasePool() {// 构造函数,创建的时候调用，内部调用了一个push的操作
atautoreleasepoolobj = objc_autoreleasePoolPush();
}
~__AtAutoreleasePool(){// 析构函数，销毁的时候调用，内部调用了一个pop操作
objc_autoreleasePoolPop(atautoreleasepoolobj);
}
void * atautoreleasepoolobj;
};
//objc_autoreleasePoolPush push操作内部调用了一个叫AutoreleasePoolPage的push方法
void *
objc_autoreleasePoolPush(void)
{
return AutoreleasePoolPage::push();
}
// pop操作里调用了 AutoreleasePoolPage 的pop方法
void
objc_autoreleasePoolPop(void *ctxt)
{
AutoreleasePoolPage::pop(ctxt);
}
由此可见，最终管理对象的是通过 AutoreleasePoolPage
class AutoreleasePoolPage
{
static pthread_key_t const key = AUTORELEASE_POOL_KEY;
static uint8_t const SCRIBBLE = 0xA3;
// AutoreleasePoolPage固定大小为4096个字节
static size_t const SIZE = PAGE_MAX_SIZE；//PAGE_MAX_SIZE = 4096
static size_t const COUNT = SIZE / sizeof(id);
magic_t const magic;
id *next;//指针指向最后一个对象的地址
pthread_t const thread;// 线程
AutoreleasePoolPage * const parent;//上一个AutoreleasePoolPage
AutoreleasePoolPage *child;// 下一个AutoreleasePoolPage
uint32_t const depth;
uint32_t hiwat;
....
}
1.每一个AutoreleasePoolPage对象占用4096个字节，除了用来存储它内部的变量 ，剩余的空间是用来存储对象的地址
2.每一个AutoreleasePoolPage能够存储的对象数量是有限的
3.所有的AutoreleasePoolPage是都通双向链表的形式连接到一起，当前AutoreleasePoolPage无法继续存储的时候，会创建的AutoreleasePoolPage继续存储
id * begin() {//用来计算存储对象地址的开始位置
// 自身内存地址的起始位置加上本身占用内存的大小
return (id *) ((uint8_t *)this+sizeof(*this));
}
id * end() {// 返回存储对象结束的位置
// 自身内存地址起始位置+ SIZE ，size是一个固定值4096
return (id *) ((uint8_t *)this+SIZE);
}
AutoreleasePoolPage push内部逻辑
static inline void *push()
{
id *dest;
if (DebugPoolAllocation) {
// 创建一个新的AutoreleasePoolPage
dest = autoreleaseNewPage(POOL_BOUNDARY);
} else {
// 创建一个新的AutoreleasePoolPage
dest = autoreleaseFast(POOL_BOUNDARY);
}
assert(dest == EMPTY_POOL_PLACEHOLDER || *dest == POOL_BOUNDARY);
return dest;
}
// 创建一个新的AutoreleasePoolPage
static inline id *autoreleaseFast(id obj)
{
// 获取当前能够添加对象的page
AutoreleasePoolPage *page = hotPage();
if (page && !page->full()) {//如果对象没有满，向里面添加
// push的时候传入的是一个POOL_BOUNDARY，说明push的时候会做一个标记点
return page->add(obj);
} else if (page) {
// 当前的page已经满了，创建新的page
return autoreleaseFullPage(obj, page);
} else {
return autoreleaseNoPage(obj);
}
}
//如果page满了，创建新的page继续添加
static __attribute__((noinline))
id *autoreleaseFullPage(id obj, AutoreleasePoolPage *page)
{
assert(page == hotPage());
assert(page->full() || DebugPoolAllocation);
// 循环遍历page，当page的child没有值的时候，新建一个page
do {
if (page->child) page = page->child;
else page = new AutoreleasePoolPage(page);
} while (page->full());
// 并且将这个新的page作为hotPage，向内部添加一个obj
// obj有可能是一个Pool_BOUNDARY边界，有可能是对象的地址
setHotPage(page);
return page->add(obj);
}
// add的添加方式
id *add(id obj)
{
assert(!full());
unprotect();
id *ret = next;
*next++ = obj;// 将属性next 指向当前添加的对象的地址
protect();
return ret;
}
当我们@autoreleasepool 的时候，首先做的就是push，进栈的操作，将一个POOL_BOUNDARY做为一个边界值放到第一个位置，每一次@autoreleasepool都会产生一个POOL_BOUNDARY，AutoreleasePoolPage能够存储的数量有限，当page无法继续存储的时候，会创建新的AutoreleasePoolPage，并将page 的child指向它
AutoreleasePoolPage pop的逻辑
void
objc_autoreleasePoolPop(void *ctxt)
{
// 向pop函数中传递的是当前__autoreleasepool的地址
AutoreleasePoolPage::pop(ctxt);
}
static inline void pop(void *token)
{
AutoreleasePoolPage *page;
id *stop;
// 判断token不是不是空的pool占位符
if (token == (void*)EMPTY_POOL_PLACEHOLDER) {
// 如果是顶级的占位符.
if (hotPage()) {// 判断有没有AutoreleasePoolPage
// 获取开始边界值的位置
pop(coldPage()->begin());
} else {
// AutoreleasePoolPage 没有被使用过，清空
setHotPage(nil);
}
return;
}
// 通过token地址获取AutoreleasePoolPage
page = pageForPointer(token);
stop = (id *)token;
// 如果stop的地址 不等于POOL_BOUNDARY的地址，
if (*stop != POOL_BOUNDARY) {
// 赋值stop 等于begin()位置的值，POOL_BOUNDARY,判断是否有值
// 判断page 的parent是否有值
//
if (stop == page->begin() && !page->parent) {
} else {
return badPop(token);
}
}
if (PrintPoolHiwat) printHiwat();
// 从next位置一直到stop位置，中间的对象都进行一次relase操作
page->releaseUntil(stop);
// 如果page为空了
if (DebugPoolAllocation && page->empty()) {
// 获取它的parent 的page，销毁当前的page
// 将parent中存储的page作为当前的page
AutoreleasePoolPage *parent = page->parent;
page->kill();
setHotPage(parent);
// 如果page 为空，parent为空，那么销毁page
} 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();
}
}
}
调用pop的时候，会根据POOL_BOUNDARY边界点的位置和next位置进行release操作。
手动创建的@autoreleasepool，会在 开的时候和结束的时候分别调用 AutoreleasePoolPage的push 和pop
那么，main函数里面的那个@autoreleasepool是何时进行 释放对象的呢？
网友评论