Please enable JavaScript.

Coggle requires JavaScript to display documents.

iOS (Runloop与线程 (RunLoop (Runloop(一次唤醒) == event loop == 时间周期？？？,…

- - - - objc_autoreleasePoolPush 和 objc_autoreleasePoolPop 的实现
        void *objc_autoreleasePoolPush(void) { return AutoreleasePoolPage::push();} void objc_autoreleasePoolPop(void *ctxt) { AutoreleasePoolPage::pop(ctxt); }
        
        static inline void *push() { return autoreleaseFast(POOL_SENTINEL); } `
        
        autoreleaseFast
        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); } }
        1）有 hotPage 并且当前 page 不满，
        并调用 page->add(obj) 方法将对象添加至 AutoreleasePoolPage 的栈中
        2）有 hotPage 并且当前 page 已满，调用 autoreleaseFullPage 初始化一个新的页，
        并调用 page->add(obj) 方法将对象添加至 AutoreleasePoolPage 的栈中。
        3）无 hotPage，调用 autoreleaseNoPage 创建一个 hotPage，
        并调用 page->add(obj) 方法将对象添加至 AutoreleasePoolPage 的栈中。
        备注：hotPage 可以理解为当前正在使用的 AutoreleasePoolPage。
        
        page->add 添加对象
        id *add(id obj) 将对象添加到自动释放池页中：
        id *add(id obj) { id *ret = next; *next = obj; next++; return ret; }
        这个方法其实就是一个压栈的操作，将对象加入 AutoreleasePoolPage 然后移动栈顶的指针。
        
        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); }
        1）既然当前内存中不存在 AutoreleasePoolPage，就要从头开始构建这个自动释放池的双向链表，也就是说，新的 AutoreleasePoolPage 是没有 parent 指针的。
        2）初始化之后，将当前页标记为 hotPage，然后会先向这个 page 中添加一个 POOL_SENTINEL 对象，来确保在 pop 调用的时候，不会出现异常。
        3）将 obj 添加到自动释放池中。
        
        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 开始遍历整个双向链表，直到：
        1）查找到一个未满的 AutoreleasePoolPage
        2）使用构造器传入 parent 创建一个新的 AutoreleasePoolPage
        3）在查找到一个可以使用的 AutoreleasePoolPage 之后，会将该页面标记成 hotPage，然后调动上面分析过的 page->add 方法添加对象。
        
        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; };
        magic 用于对当前 AutoreleasePoolPage 完整性的校验
        thread 保存了当前页所在的线程
        
        void objc_autoreleasePoolPop(void *ctxt) { AutoreleasePoolPage::pop(ctxt); }
        在这个方法中传入其它的指针也是可行的，会将自动释放池释放到相应的位置。
        我们一般都会在这个方法中传入一个哨兵对象 POOL_SENTINEL。
        
        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(); } } }
        在这个方法中删除了大量无关的代码，以及对格式进行了调整。
        该静态方法总共做了三件事情：
        1)使用 pageForPointer 获取当前 token 所在的 AutoreleasePoolPage
        2)调用 releaseUntil 方法释放栈中的对象，直到 stop
        3)调用 child 的 kill 方法
        
        pageForPointer 获取 AutoreleasePoolPage
        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 = 0x100816048p % SIZE = 0x48result = 0x100816000
        而最后调用的方法 fastCheck() 用来检查当前的 result 是不是一个 AutoreleasePoolPage。
        
        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() 方法
        它会将当前页面以及子页面全部删除：
        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); }
    - - int main(int argc, const char * argv[]) { { void * atautoreleasepoolobj = objc_autoreleasePoolPush(); // do whatever you want objc_autoreleasePoolPop(atautoreleasepoolobj); } return 0; }
        
        而当方法 objc_autoreleasePoolPop 调用时，就会向自动释放池中的对象发送 release 消息，直到第一个 POOL_SENTINEL。
        
        上面的 atautoreleasepoolobj 就是一个 POOL_SENTINEL。POOL_SENTINEL（哨兵对象）， POOL_SENTINEL 只是 nil 的别名#define POOL_SENTINEL nil
        
        在每个自动释放池初始化调用 objc_autoreleasePoolPush 的时候，都会把一个 POOL_SENTINEL push 到自动释放池的栈顶，并且返回这个 POOL_SENTINEL 哨兵对象。
    - - 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; }