iOS 底層拾遺：AutoreleasePool

時間 2019-11-06

原文原文鏈接

前言

在陽神的黑幕背後的Autorelease 文章中已經把 AutoreleasePool 核心邏輯講明白了，不過可能是結論性的東西，筆者通讀源碼以探究更多的細節，驗證一下老生常談的一些結論。前端

源碼基於 Runtime 750。數組

1、@autoreleasepool {} 幹了些什麼

main.m 文件代碼：安全

int main(int argc, const char * argv[]) {
    @autoreleasepool {}
    return 0;
}
複製代碼

使用 clang -rewrite-objc main.m 查看通過編譯器前端處理的代碼：bash

struct __AtAutoreleasePool {
  __AtAutoreleasePool() {atautoreleasepoolobj = objc_autoreleasePoolPush();}
  ~__AtAutoreleasePool() {objc_autoreleasePoolPop(atautoreleasepoolobj);}
  void * atautoreleasepoolobj;
};

int main(int argc, const char * argv[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; }
    return 0;
}
複製代碼

能夠看出@autoreleasepool{}會建立一個__AtAutoreleasePool類型的局部變量幷包含在當前做用域，__AtAutoreleasePool構造和析構時分別調用了兩個方法，因此簡化過程以下：數據結構

void *context = objc_autoreleasePoolPush()
// 對象調用 autorelease 裝入自動釋放池
objc_autoreleasePoolPop(context)
複製代碼

能夠猜想 push 和 pop 操做是實現自動釋放的關鍵。併發

2、AutoreleasePoolPage 內存分佈

官方文檔中提到了，主線程以及非顯式建立的線程（好比 GCD）都會有一個 event loop (RunLoop 就是具體實現)，在 loop 的每個循環週期的開始和結束會分別調用自動釋放池的 push 和 pop 方法，由此來實現自動的內存管理。由此也能夠肯定，自動釋放池是與線程一一對應的。app

objc_autoreleasePoolPush()和objc_autoreleasePoolPop(...)實際上會調用到AutoreleasePoolPage類的push()和pop()方法，先看一下這個類的數據結構：less

class AutoreleasePoolPage {
    ...
    magic_t const magic;
    id *next;
    pthread_t const thread;
    AutoreleasePoolPage * const parent;
    AutoreleasePoolPage *child;

    static void * operator new(size_t size) {
        return malloc_zone_memalign(malloc_default_zone(), SIZE, SIZE);
    }
    id * begin() {
        return (id *) ((uint8_t *)this+sizeof(*this));
    }
    id * end() {
        return (id *) ((uint8_t *)this+SIZE);
    } 
    ...
}
複製代碼

parent和child正是指向前驅和後繼指針，自動釋放池就是一個以AutoreleasePoolPage爲節點的雙向鏈表（後文驗證）。
thread是指當前 page 所對應的線程。
magic用於校驗內存是否損壞。
next指向當前可插入對象的地址。

內存對齊

重寫了new運算符，使用了malloc_zone_memalign(...)進行內存分配：異步

extern void *malloc_zone_memalign(malloc_zone_t *zone, size_t alignment, size_t size) ;
    /* 
     * Allocates a new pointer of size size whose address is an exact multiple of alignment.
     * alignment must be a power of two and at least as large as sizeof(void *).
     * zone must be non-NULL.
     */
複製代碼

註釋說得很清楚了，這個方法以alignment對齊的地址分配size的內存空間。調用時兩個參數都使用了SIZE宏，實際上就是虛擬內存頁的大小：oop

#define I386_PGBYTES 4096
複製代碼

一個 page 的內存空間設置太小會致使更多的開闢空間操做下降效率，大量的parent/child指針變量也會佔用可觀的內存；空間設置過大可能會致使一個 page 的利用率低浪費過多內存。設置爲 4096 是比較考究的，在保證內存對齊的狀況下最大化利用空間避免內存碎片。這麼作事後 page 的地址老是 4096 的整數倍，可讓某些運算更便捷（好比後文會說的經過指針地址尋找對應的 page）。

begin() 與 end()

AutoreleasePoolPage自己的大小遠不及 4096，而超出的空間正是用來存放「指望被自動管理的對象」。begin()和end()方法標記了這個範圍。

sizeof(*this)表示AutoreleasePoolPage自己的大小，那麼(uint8_t *)this+sizeof(*this)就是最低地址，(uint8_t *)this+SIZE就是最高地址。逐個插入對象時，next指針從begin()到end()逐個移動，後面的full()方法就是指next == end()，empty()就是指next == begin()。

值得注意的是next/end()/begin()等都是id *類型的，即指向指針的指針，進行 +1 -1 運算時移動的是一個id大小的距離。

3、push 邏輯

push()方法會調用autoreleaseFast(POOL_BOUNDARY)：

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 指的是當前可插入對象的 page，放到後面一點分析，先來看插入對象的邏輯，分三種狀況：

一、當 page 存在且沒滿時，直接添加對象：

id *add(id obj)
    {
        assert(!full());
        unprotect();
        id *ret = next;  // faster than `return next-1` because of aliasing
        *next++ = obj;
        protect();
        return ret;
    }
複製代碼

unprotect()/protect()內部使用了int mprotect(void *a, size_t b, int c)，設置內存起點a長度b的內存區域爲c類型的訪問限制：

inline void protect() {
#if PROTECT_AUTORELEASEPOOL
        mprotect(this, SIZE, PROT_READ);
        check();
#endif
    }
    inline void unprotect() {
#if PROTECT_AUTORELEASEPOOL
        check();
        mprotect(this, SIZE, PROT_READ | PROT_WRITE);
#endif
    }
複製代碼

unprotect()設置爲可讀可寫，protect()設置爲只讀，因此這裏的目的是保證 page 寫安全。不過有#define PROTECT_AUTORELEASEPOOL 0定義說明目前版本尚未開放這個保護功能。

二、當 page 存在且滿了時，拓展 page 節點並添加對象：

static __attribute__((noinline))
    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);
    }
複製代碼

循環的邏輯：從 child 方向找到未滿的 page，若找不到則建立一個新 page 拼接到鏈表尾部（AutoreleasePoolPage 構造方法會把傳入的 page 參數做爲 parent 前驅對象）。後面再設置最新的 page 爲 hotpage 並將 obj 添加進 page。

三、當 page 不存在時，初始化一個

static __attribute__((noinline))
    id *autoreleaseNoPage(id obj) 
    {   ...
        AutoreleasePoolPage *page = new AutoreleasePoolPage(nil);
        setHotPage(page);
        ...
        return page->add(obj);
    }
複製代碼

這個方法核心就是建立第一個 page 而後加入線程局部存儲。

hotPage

從上面的push()方法分析可知，被自動管理的對象會不斷插入雙向鏈表從前到後第一個未滿 page ，hotPage()其實就是指向這個 page，還有個coldPage()方法是根據hotPage()找到第一個 page。

既然自動釋放池是由AutoreleasePoolPage組成的雙向鏈表，那這個鏈表該如何訪問呢？可能常規的思路是建立一個全局變量來訪問它，不過這裏使用了另一個方式：

static inline AutoreleasePoolPage *hotPage() 
    {
        AutoreleasePoolPage *result = (AutoreleasePoolPage *)
            tls_get_direct(key);
        // EMPTY_POOL_PLACEHOLDER 表示沒有 page
        if ((id *)result == EMPTY_POOL_PLACEHOLDER) return nil;
        if (result) result->fastcheck();
        return result;
    }
    static inline void setHotPage(AutoreleasePoolPage *page) 
    {
        if (page) page->fastcheck();
        tls_set_direct(key, (void *)page);
    }
複製代碼

tls_get_direct(...)和tls_set_direct(...)內部就是使用線程的局部存儲（TLS: Thread Local Storage）將 page 存儲起來，這樣能夠避免維護額外的空間來記錄尾部的 page。由此也驗證了自動釋放池與線程一一對應的關係。

在 YYKit 中有一個使用普遍的技巧：將某個對象最後使用時放在異步線程，若是這個對象釋放就（可能?）會在這個異步線程，從而下降主線程壓力。實際上就是編譯器插入 autorelease 代碼將對象加入到異步線程的自動釋放池，而若是異步線程的釋放池先於主線程的釋放池pop()而調用對象的release()方法，那麼這個對象若是釋放就會在異步線程。因此筆者認爲這個優化並不是絕對有效（這裏衍生出一個問題：一個對象被多個自動釋放池管理，若對象釋放這些釋放池怎麼避免的野指針問題？）。

POOL_BOUNDARY

push()方法調用autoreleaseFast(POOL_BOUNDARY)時傳入的是一個 POOL_BOUNDARY 並不是須要被管理的對象，它的定義以下：

# define POOL_BOUNDARY nil
複製代碼

在調用autoreleaseFast(obj)方法會返回指向obj指針的指針，它是一個id *類型，也就是說，這個返回值關心的只是obj指針的地址，而不是obj值的地址，obj指針的地址就是對應AutoreleasePoolPage對象內存中的某段區域。

再看一下上層調用：

void *context = objc_autoreleasePoolPush()
...
objc_autoreleasePoolPop(context)
複製代碼

pop 時會將這個obj指針的地址傳入進去。pop 的邏輯是把 hotPage 裏面裝的對象依次移除併發送 release 消息（後面會詳細分析），當前 page 移除完了，繼續移除 parent 節點內的對象，以此反覆，而移除對象操做什麼時候中止就是到這個obj指針的地址。

因此，push 操做加入一個 POOL_BOUNDARY 實際上就是加一個邊界，pop 操做時根據邊界判斷範圍，這就是一個入棧與出棧的過程。

magic 校驗

屢次出現的check()方法以下：

void check(bool die = true)  {
        if (!magic.check() || !pthread_equal(thread, pthread_self())) busted(die);
    }
    void fastcheck(bool die = true)  {
//補充：#define CHECK_AUTORELEASEPOOL (DEBUG)
#if CHECK_AUTORELEASEPOOL
        check(die);
#else
        if (! magic.fastcheck()) busted(die);
#endif
    }
複製代碼

能夠看到，它們都調用了magic的 check 方法，在 DEBUG 時還會去檢查當前線程是否與 page 的線程一致。

magic是magic_t類型的，這個結構體主要是有個uint32_t m[4];數組，構造時內存直接會寫爲0xA1A1A1A1 AUTORELEASE!，而後check()邏輯就是判斷構造時的值是否發生了改變，若發生改變說明這個 page 已經被破壞。

4、autorelease 邏輯

上層對象調用 autorelease 方法會調用到AutoreleasePoolPage的如下方法：

static inline id autorelease(id obj)
    {
        assert(obj);
        assert(!obj->isTaggedPointer());
        id *dest __unused = autoreleaseFast(obj);
        assert(!dest  ||  dest == EMPTY_POOL_PLACEHOLDER  ||  *dest == obj);
        return obj;
    }
複製代碼

顯然，最終仍是會調用前面解析的autoreleaseFast(...)方法進行對象插入。由此也能夠推斷，在一個 Thread 沒有 Runloop 自動執行自動釋放池的 push 和 pop 時，對象進行 autorelease 時若發現沒有自動釋放池節點會自動建立 page 並加入線程局部存儲（參考前面的autoreleaseNoPage(...)方法分析）。

5、pop 邏輯

objc_autoreleasePoolPop(context)的context參數是objc_autoreleasePoolPush()返回的，實際上就是POOL_BOUNDARY對應的在AutoreleasePoolPage中的地址。最終會調用到pop()方法：

static inline void pop(void *token) 
    {
        AutoreleasePoolPage *page;
        id *stop;
        ...
        // 拿到 token 邊界對應的 page
        page = pageForPointer(token);
        stop = (id *)token;
        ...
        // pop 內部對象直到 stop 邊界
        page->releaseUntil(stop);
        ...
        // 刪除空的 child 鏈表節點，若是當前頁對象超過一半，保留下一個空節點
        if (page->lessThanHalfFull()) {
            page->child->kill();
        }
        else if (page->child->child) {
            page->child->child->kill();
        }
    }
複製代碼

pop()的邏輯應該很好理解了，token參數就是邊界，下面分別分析步驟：

找到邊界對應的 page

static AutoreleasePoolPage *pageForPointer(const void *p) {
        return pageForPointer((uintptr_t)p);
    }
    static AutoreleasePoolPage *pageForPointer(uintptr_t p) {
        AutoreleasePoolPage *result;
        uintptr_t offset = p % SIZE;
        ....
        result = (AutoreleasePoolPage *)(p - offset);
        result->fastcheck();
        return result;
    }
複製代碼

onst void *p是指針的指針，((uintptr_t)p)才表示POOL_BOUNDARY指針在對應 page 中的地址。

前面分析過內存對齊的處理，那麼uintptr_t p的值必然是 SIZE (4096) 的倍數，那麼p % SIZE就獲得了這個p在 page 中的地址偏移，最後經過p - offset就拿到了 page 的起始地址，這個處理比較秀。

移除被管理對象併發送 release 消息

void releaseUntil(id *stop)  {
        while (this->next != stop) {
            AutoreleasePoolPage *page = hotPage();
            // 若是當前 page 空了，指向 parent
            while (page->empty()) {
                page = page->parent;
                setHotPage(page);
            }
            // 將即將要移除對象對應 page 中的內存置爲 SCRIBBLE
            page->unprotect();
            id obj = *--page->next;
            memset((void*)page->next, SCRIBBLE, sizeof(*page->next));
            page->protect();
            // 調用對象的 release 方法
            if (obj != POOL_BOUNDARY) {
                objc_release(obj);
            }
        }
        // 把當前 page 設置 hotpage（調用時 this 就是對應指望釋放邊界的 page）
        setHotPage(this);
        ...
    }
複製代碼

清除 child

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);
    }
複製代碼

這個邏輯一目瞭然了。

後語

以上就是自動釋放池大部分源碼的分析了，這部分源碼沒有涉及彙編而且代碼量比較少，因此看起來相對容易。多理解一些內存管理底層有利於理解各類上層特性、定位內存難題，也有助於寫出更穩定的代碼。而且在這個過程當中，不可避免須要接觸操做系統和編譯原理相關知識，也算是能培養通識性能力。

讀源碼遠比記結論重要，遇到某些優秀的代碼細節每每使人驚喜，不失爲一種樂趣。

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。