1.探究autoreleasepool是什么东西

1.clang探究autoreleasepool本质

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // insert code here...
        NSLog(@"Hello, World!");
    }
    return 0;
}

 clang -rewrite-objc main.m -o main.cpp

clang之后的代码

int main(int argc, const char * argv[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 

        NSLog((NSString *)&__NSConstantStringImpl__var_folders_l2_ftcx04s56rs4kd9gct484_740000gq_T_main_b274fe_mi_0);
    }
    return 0;
}
struct __AtAutoreleasePool {
  __AtAutoreleasePool() {atautoreleasepoolobj = objc_autoreleasePoolPush();}
  ~__AtAutoreleasePool() {objc_autoreleasePoolPop(atautoreleasepoolobj);}
  void * atautoreleasepoolobj;
};

我们看出__AtAutoreleasePool是c++写的结构体，里面有一个构造函数和析构函数。我们也可以自定义这种c++的结构体

struct MyTest {
    MyTest(){
        printf("创建函数");
    }
    ~MyTest(){
        printf("析构函数");
    }
};
//在某个作用域调用
{
        MyTest mytest;
}
//打印结果
创建函数析构函数

我们可以看出__AtAutoreleasePool的创建函数是创建一个对象，析构函数是pop这个对象。从源码分析自动释放池
2.汇编看@autoreleasepool的本质

image.png

objc_autoreleasePoolPush和objc_autoreleasePoolPop就是上面clang中__AtAutoreleasePool结构体构建函数和析构函数的调用方法。

2.从源码看自动释放池的结构

2.1apple对自动释放池的介绍 (在objc源码中)

Autorelease pool implementation
A thread's autorelease pool is a stack of pointers.
Each pointer is either an object to release, or POOL_BOUNDARY which is
an autorelease pool boundary.
A pool token is a pointer to the POOL_BOUNDARY for that pool. When
the pool is popped, every object hotter than the sentinel is released.
The stack is divided into a doubly-linked list of pages. Pages are added
and deleted as necessary.
Thread-local storage points to the hot page, where newly autoreleased
objects are stored.

1.线程的自动释放池是一个指针的栈结构，
2.栈结构中存放要释放的指针和自动释放池的哨兵(边界)。
3.自动释放池是页的结构并且是双向链表
4.用线程本地存储指向hot页

2.2源码看结构

objc_autoreleasePoolPush(void)
{
    return AutoreleasePoolPage::push();
}

AutoreleasePoolPage是类，继承自AutoreleasePoolPageData，说明我们自动释放池的本质是一个对象。

struct AutoreleasePoolPageData
{
    magic_t const magic;
    __unsafe_unretained id *next;
    pthread_t const thread;
    AutoreleasePoolPage * const parent;
    AutoreleasePoolPage *child;
    uint32_t const depth;
    uint32_t hiwat;
};

我们可以看出AutoreleasePoolPageData结构体中有parent和child，这就是双向链表的体现。
magic ：用来校验 AutoreleasePoolPage 的结构是否完整
next ：指向最新添加的 autoreleased 对象的下一个位置，初始化时指向begin()
thread ：指向当前线程
parent ：指向父结点，第一个结点的 parent 值为 nil
child ：指向子结点，最后一个结点的 child 值为 nil
depth：代表深度，从 0 开始，往后递增 1
hiwat： 代表 high water mark 最大入栈数量标记

创建自动释放池

我们可以看到在AutoreleasePoolPage中有一个构造方法

    AutoreleasePoolPage(AutoreleasePoolPage *newParent) :
        AutoreleasePoolPageData(begin(),
                                objc_thread_self(),
                                newParent,
                                newParent ? 1+newParent->depth : 0,
                                newParent ? newParent->hiwat : 0)

参数中，objc_thread_self是从tls拿到线程，其他参数都是调用者传来的，但是begin是什么呢？

  id * begin() {
        return (id *) ((uint8_t *)this+sizeof(*this));
    }

通过联调我们知道sizeof(*this)是56，为什么呢？我们来看结构体AutoreleasePoolPageData的内存布局

struct magic_t {
    static const uint32_t M0 = 0xA1A1A1A1; //静态不占字节
#   define M1 "AUTORELEASE!"
    static const size_t M1_len = 12;//静态不占字节
    uint32_t m[4]; //16字节
}
struct AutoreleasePoolPageData
{
    magic_t const magic; //16字节
    __unsafe_unretained id *next; //指针类型8字节
    pthread_t const thread; //指针类型占8字节
    AutoreleasePoolPage * const parent;//8字节
    AutoreleasePoolPage *child;//8字节
    uint32_t const depth;//4字节
    uint32_t hiwat;//4字节
}

所以偏移56个字节
所以就有下面的结构

image.png image.png

2.3通过打印看自动释放池内的对象

extern void _objc_autoreleasePoolPrint(void);

   @autoreleasepool {

       
        NSObject *objc1 = [NSObject new] ;
        NSObject *objc2 = [NSObject new] ;
        NSObject *objc3 = [NSObject new] ;
        NSObject *objc4 = [NSObject new] ;
        NSObject *objc5 = [NSObject new] ;


        _objc_autoreleasePoolPrint();
    }

不打印，我们改成MRC并修改代码

  @autoreleasepool {

        for (int i = 0 ; i< 5; i++) {
            NSObject *objc1 = [[NSObject new] autorelease] ;
       
        }

        _objc_autoreleasePoolPrint();
    }

打印结果

objc[93582]: ##############
objc[93582]: AUTORELEASE POOLS for thread 0x1000dedc0
objc[93582]: 6 releases pending.
objc[93582]: [0x103012000]  ................  PAGE  (hot) (cold)
objc[93582]: [0x103012038]  ################  POOL 0x103012038
objc[93582]: [0x103012040]       0x1019325a0  NSObject
objc[93582]: [0x103012048]       0x101930e70  NSObject
objc[93582]: [0x103012050]       0x1019058d0  NSObject
objc[93582]: [0x103012058]       0x10192f5c0  NSObject
objc[93582]: [0x103012060]       0x10192eb90  NSObject
objc[93582]: ##############

我们明明压进去5个指针，为什么显示6个对象指针呢？
POOL 0x103012038为我们的边界。

2.4一个AutoreleasePoolPage到底有多大

 id * end() {
        return (id *) ((uint8_t *)this+SIZE);
    }
SIZE = PAGE_MIN_SIZE;
PAGE_MIN_SIZE = 1<<12

1<<12 = 4096,我们知道AutoreleasePoolPage自己占56个字节，（4096-56）/8 = 505，因为有一个边界占一个8字节，所以能存放504个指针。

  for (int i = 0 ; i< 505; i++) {
            NSObject *objc1 = [[NSObject new] autorelease] ;
            
        }
        NSLog(@"------");
        _objc_autoreleasePoolPrint();
//打印结果 只截取后面部分
objc[71301]: [0x102009000]  ................  PAGE  (hot) 
objc[71301]: [0x102009038]       0x101852d40  NSObject
objc[71301]: ##############

到505时，又创建一个page，把505存储到新建的page里。
那第2个page能存多少个呢？

        for (int i = 0 ; i< 504+506; i++) {
            NSObject *objc1 = [[NSObject new] autorelease] ;
            
        }

我们知道第一个page里面会存504个指针，如果第二个page也存504个指针，那么第三个page里还有两个指针。如果第二个page存505个对象指针，第三个page 里有一个指针。打印结果只copy最后部分

objc[72598]: [0x10200dff0]       0x101151d20  NSObject
objc[72598]: [0x10200dff8]       0x101151d30  NSObject
objc[72598]: [0x102813000]  ................  PAGE  (hot) 
objc[72598]: [0x102813038]       0x101151d40  NSObject
objc[72598]: ##############

从打印结果看，第二个page里面存505个指针，除了第一个page，再后面的page中不会重新创建边界对象。

3.创建自动释放池

AutoreleasePoolPage::push();
  static inline void *push() 
    {
        id *dest;
        if (slowpath(DebugPoolAllocation)) {
 //可以通过设置环境来设置DebugPoolAllocation为true
            // Each autorelease pool starts on a new pool page.
            dest = autoreleaseNewPage(POOL_BOUNDARY);
        } else {
            dest = autoreleaseFast(POOL_BOUNDARY); //POOL_BOUNDARY为nil
        }
        ASSERT(dest == EMPTY_POOL_PLACEHOLDER || *dest == POOL_BOUNDARY);
        return dest;
    }
//第一个obj为nil
    static inline id *autoreleaseFast(id obj)
    {
        AutoreleasePoolPage *page = hotPage();
        if (page && !page->full()) { 
//hotpage存在，并且没有满，直接向page中加指针
            return page->add(obj);
        } else if (page) {
//page存在，并且满了
            return autoreleaseFullPage(obj, page);
        } else {
//hotpage不存在
            return autoreleaseNoPage(obj);
        }
    }

因为我们第一次创建，所以我们重点判断hotpage不存在的情况

static __attribute__((noinline))
    id *autoreleaseNoPage(id obj)
{
            return setEmptyPoolPlaceholder();
}

因为obj是空的，并且DebugPoolAllocation我们没在环境变量中设置所以我们得到一个空的占位符。当我们向里面加入对象指针时，初始化完成。

3压栈

3.1第一次压栈

在mrc中，一个对象autorelease，就实现了向自动释放池中压栈。
autorelease--》_objc_rootAutorelease(self)--->obj->rootAutorelease()---->rootAutorelease2()--->AutoreleasePoolPage::autorelease((id)this)--->autoreleaseFast(obj)
autoreleaseFast中会判断hotpage，因为我们在创建的时候会搞一个占位符，所以hotpage返回是NULL,重新走autoreleaseNoPage(obj)

  id *autoreleaseNoPage(id obj) {
   bool pushExtraBoundary = false;
        if (haveEmptyPoolPlaceholder()) {
           pushExtraBoundary = true;
        }
//创建新的page
   AutoreleasePoolPage *page = new AutoreleasePoolPage(nil);
        setHotPage(page);
        
        // Push a boundary on behalf of the previously-placeholder'd pool.
//向page中加入边界(哨兵)
        if (pushExtraBoundary) {
            page->add(POOL_BOUNDARY);
        }
        
        // Push the requested object or pool.
//压入我们真正的对象
        return page->add(obj);
}

3.2第n次压栈

如果压入的对象不是在刚才线程，则会重新创建page，重新上面步骤。

  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，没有满，则直接存储对象指针，并让next++；
我们着重研究hotpage满了的情况：

    id *autoreleaseFullPage(id obj, AutoreleasePoolPage *page)
    {
        // The hot page is full. 
        // Step to the next non-full page, adding a new page if necessary.
        // Then add the object to that page.
        ASSERT(page == hotPage());
        ASSERT(page->full()  ||  DebugPoolAllocation);

        do {
            if (page->child) page = page->child;
            else page = new AutoreleasePoolPage(page);
        } while (page->full());

        setHotPage(page);
        return page->add(obj);
    }

判断child page是否存在，如果存在则设置page为子page，并判断page是否满了，如果不满，则获取page，并设置当前page为hotpage，并向page中压入对象，如果判断到childpage为nil，则重新创建page，在创建page时，会传入原来page中最后的子page，让把创建的page作为最后子page的子page，再设置hotpage并压入对象指针。

自动释放池释放

objc_autoreleasePoolPop实现对指针的释放
objc_autoreleasePoolPop===> pop(void *token)====> popPage(void *token, AutoreleasePoolPage *page, id *stop)====>releaseUntil(id *stop)
在pop(void *token)中page = pageForPointer(token);，取到最子page，在releaseUntil中对page中对象释放。

void releaseUntil(id *stop) 
{
        // Not recursive: we don't want to blow out the stack 
        // if a thread accumulates a stupendous amount of garbage
        
        while (this->next != stop) {
            // Restart from hotPage() every time, in case -release 
            // autoreleased more objects
            AutoreleasePoolPage *page = hotPage();

            // fixme I think this `while` can be `if`, but I can't prove it
            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_BOUNDARY) {
                objc_release(obj);
            }
        }
  setHotPage(this);

#if DEBUG
        // we expect any children to be completely empty
        for (AutoreleasePoolPage *page = child; page; page = page->child) {
            ASSERT(page->empty());
        }
#endif
    }

对压入栈的对象进行释放，并对page中对象所占内存进行处理memset。
在popPage中有对自动释放池释放
page->kill();并设置父page为hotpage，删除所有的子page。

4自动释放池嵌套

    @autoreleasepool {

        NSObject *objc1 = [[NSObject new] autorelease] ;

        @autoreleasepool {
            for (int i = 0 ; i< 5; i++) {
                NSObject *objc = [[NSObject new] autorelease] ;
            }
            _objc_autoreleasePoolPrint();

        }
        NSObject *objc2 = [[NSObject new] autorelease] ;
        NSObject *objc3 = [[NSObject new] autorelease] ;

        _objc_autoreleasePoolPrint();
    }

嵌套内的打印

objc[77336]: ##############
objc[77336]: AUTORELEASE POOLS for thread 0x1000dedc0
objc[77336]: 8 releases pending.
objc[77336]: [0x10180c000]  ................  PAGE  (hot) (cold)
objc[77336]: [0x10180c038]  ################  POOL 0x10180c038
objc[77336]: [0x10180c040]       0x1010408a0  NSObject
objc[77336]: [0x10180c048]  ################  POOL 0x10180c048
objc[77336]: [0x10180c050]       0x101040360  NSObject
objc[77336]: [0x10180c058]       0x10103ec30  NSObject
objc[77336]: [0x10180c060]       0x10103d350  NSObject
objc[77336]: [0x10180c068]       0x10103c920  NSObject
objc[77336]: [0x10180c070]       0x10103d250  NSObject
objc[77336]: ##############

最外面自动释放池打印

objc[77336]: ##############
objc[77336]: AUTORELEASE POOLS for thread 0x1000dedc0
objc[77336]: 4 releases pending.
objc[77336]: [0x10180c000]  ................  PAGE  (hot) (cold)
objc[77336]: [0x10180c038]  ################  POOL 0x10180c038
objc[77336]: [0x10180c040]       0x1010408a0  NSObject
objc[77336]: [0x10180c048]       0x10068c190  NSObject
objc[77336]: [0x10180c050]       0x10068eb10  NSObject
objc[77336]: ##############

我们看出嵌套内的自动释放池没有重新创建释放池，但是多加了一个边界。
第二层自动释放池中push时，因为有hotpage并且没有满，所以直接压进去一个空。我再看一下释放的时候，void releaseUntil(id *stop)中有对对象进行非空判断，POOL_BOUNDARY就是nil

 define POOL_BOUNDARY nil