内存管理：autorelease、autoreleasepool

一、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是何时进行释放对象的呢？