您现在的位置: IOS教程網 >> IOS系統 >  >> iOS 程式開發 >> iOS 開發基礎

自動釋放池的前世今生:Objective-C 內存管理源碼剖析

編輯:iOS 開發基礎

關注倉庫,及時獲得更新:iOS-Source-Code-Analyze

Objective-C 的內存管理是個大話題,因此拆成兩篇來講:這篇聚焦自動釋放池與 autorelease 方法,另一篇則分析 retain、release 與自動引用計數。

寫在前面

本文從源碼層面梳理 Objective-C 中自動釋放池的實現,以及方法調用 autorelease 時究竟發生了什麼。

從 main 函數說起

main 函數是整個 iOS 開發中最不起眼的存在,它安靜地躲在 Supporting Files 文件夾裡,卻是應用的真正入口。

// main.m
int main(int argc, char * argv[]) {
    @autoreleasepool {
        return UIApplicationMain(argc, argv, nil, NSStringFromClass([AppDelegate class]));
    }
}

這個 @autoreleasepool block 裡只有一行代碼,把所有事件與消息都交給 UIApplication 處理——這不是本文的重點。重點是:整個 iOS 應用的生命周期都包在一個自動釋放池 block 之中。

@autoreleasepool 到底是什麼

用 clang 讓編譯器把這個文件重新寫一遍:

$ clang -rewrite-objc main.m

一堆警告之後,當前目錄多了一個 main.cpp。仔細看會發現一個古怪的結構體 __AtAutoreleasePool,註釋寫著 /* @autoreleasepool */。也就是說,@autoreleasepool {} 被翻譯成了一個 __AtAutoreleasePool 對象:

{
    __AtAutoreleasePool __autoreleasepool;
}

繼續在 main.cpp 中查找這個結構體的定義:

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

    void * atautoreleasepoolobj;
};

構造時調用 objc_autoreleasePoolPush(),析構時調用 objc_autoreleasePoolPop()。所以 main 函數實際的形態是這樣:

int main(int argc, const char * argv[]) {
    {
        void * atautoreleasepoolobj = objc_autoreleasePoolPush();
        // do whatever you want
        objc_autoreleasePoolPop(atautoreleasepoolobj);
    }
    return 0;
}

@autoreleasepool 語法糖的作用,僅僅是幫我們省下這兩行代碼。要理解自動釋放池,就得沿著這兩個方法往下挖。

AutoreleasePoolPage:真正的容器

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

void objc_autoreleasePoolPop(void *ctxt) {
    AutoreleasePoolPage::pop(ctxt);
}

這兩個函數只是對 AutoreleasePoolPage 靜態方法的封裝。接下來按三個部分拆解:AutoreleasePoolPage 的結構、push 的實現、pop 的實現。

類的定義

AutoreleasePoolPage 是 NSObject.mm 中的一個 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 用於校驗當前頁的完整性,thread 記錄所屬線程。一個自動釋放池由一系列 AutoreleasePoolPage 串成,每頁大小固定為 4096 字節:

#define I386_PGBYTES  4096
#define PAGE_SIZE     I386_PGBYTES

雙向鏈表

這些頁以雙向鏈表的形式連接,parent 與 child 就是鏈表指針。

頁內部的棧結構

假設某個 AutoreleasePoolPage 分佈在 0x100816000 ~ 0x100817000,那麼它的內存佈局是:開頭約 56 字節存放成員變量,剩下的 0x100816038 ~ 0x100817000 用來存放對象指針。

begin() 與 end() 兩個實例方法用來快速取得這段可用空間的邊界。next 始終指向下一個空位,每加入一個對象,next 就順次後移。

至於 hiwat 與 depth,它們不影響自動釋放池的核心邏輯,也不在關鍵調用棧上,這裡不展開。

POOL_SENTINEL:棧底的哨兵

POOL_SENTINEL 到底是什麼?答案樸素得讓人意外——它就是 nil 的別名。

#define POOL_SENTINEL nil

每次調用 objc_autoreleasePoolPush 創建自動釋放池時,都會把一個 POOL_SENTINEL 壓到棧頂,並把它作為返回值交給調用方。上面例子裡的 atautoreleasepoolobj 就是這個哨兵。而 objc_autoreleasePoolPop 被調用時,會從棧頂往下給每個對象發 release 消息,直到遇到第一個 POOL_SENTINEL 才停下。

objc_autoreleasePoolPush 的實現

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);
    }
}

三個分支對應三種情形:

  • 存在 hotPage 且當前頁未滿:直接 page->add(obj)。
  • 存在 hotPage 但當前頁已滿:調用 autoreleaseFullPage 找到或新建頁,再 page->add(obj)。
  • 不存在 hotPage:調用 autoreleaseNoPage 創建頁,再 page->add(obj)。

最終都會走到 page->add(obj)。這裡的 hotPage 可以理解為「當前正在使用的頁」。

add:一次壓棧

id *add(id obj) {
    id *ret = next;
    *next = obj;
    next++;
    return ret;
}

為方便理解,這裡做了些簡化。本質上就是壓棧:把對象寫入當前空位,然後把棧頂指針後移一格。

autoreleaseFullPage:當前頁已滿

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);
}

它從傳入的頁出發遍歷雙向鏈表,直到找到一個未滿的頁,或者用構造器傳入 parent 新建一頁。找到可用頁後把它標記為 hotPage,再調用 add 壓入對象。

autoreleaseNoPage:一個 hotPage 都沒有

static id *autoreleaseNoPage(id obj) {
    AutoreleasePoolPage *page = new AutoreleasePoolPage(nil);
    setHotPage(page);

    if (obj != POOL_SENTINEL) {
        page->add(POOL_SENTINEL);
    }
    return page->add(obj);
}

此時內存中不存在任何頁,需要從頭搭建鏈表,因此新頁沒有 parent。初始化後標記為 hotPage,並先壓入一個 POOL_SENTINEL 作為兜底,保證後續 pop 不會越界,最後才把 obj 加入。

objc_autoreleasePoolPop 的實現

void objc_autoreleasePoolPop(void *ctxt) {
    AutoreleasePoolPage::pop(ctxt);
}

從簽名看,傳入任意指針似乎都行,實踐中工程裡只見哨兵對象。不過傳入其他指針技術上可行,效果是把自動釋放池釋放到該指針對應的位置。

做個小實驗:傳入非哨兵參數

#import <Foundation/Foundation.h>

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        NSString *s = @"Draveness";
        [s stringByAppendingString:@"-Suffix"];
    }
    return 0;
}

在 stringByAppendingString: 這一行下斷點,因為這裡會產生一個 autorelease 對象並壓入池中。

程序停在斷點時,用 lldb 打印當前 hotPage 的棧內容:

  • 通過靜態方法取得當前 hotPage;
  • 打印 AutoreleasePoolPage 的內容;
  • 查看 next 及其之前的位置(-2 處已到 begin());
  • 用 print() 與 printAll() 輸出池內對象。

接著把字符串 "Draveness-Suffix" 的指針傳給 pop:

再次打印會發現字符串已被釋放。這說明傳入非哨兵參數是可行的,只是實踐中沒有這麼做的理由。

pop 的三件事

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();
        }
    }
}

這裡刪去了大量無關代碼並調整了格式。它做了三件事:用 pageForPointer 定位 token 所在頁;調用 releaseUntil 釋放棧中對象直到 stop;再根據頁面填充程度 kill 掉相應的 child 頁。

pageForPointer:從地址反推頁首

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 對齊的,所以指針對頁大小取模就能得到偏移量,減掉偏移即為頁首地址:

p         = 0x100816048
p % SIZE  = 0x48
result    = 0x100816000

最後的 fastCheck() 用來確認 result 真的是一個 AutoreleasePoolPage,判斷依據是 magic 結構體中的某個成員是否為 0xA1A1A1A1。

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);
}

邏輯很直白:循環彈棧,直到 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);
}

它先找到最深的子頁,然後從下往上一頁頁 delete,直到把當前頁也刪掉。

autorelease 方法的調用鏈

最後來看 autorelease 方法本身,調用棧如下:

- [NSObject autorelease]
  └── id objc_object::rootAutorelease()
        └── id objc_object::rootAutorelease2()
              └── static id AutoreleasePoolPage::autorelease(id obj)
                    └── static id AutoreleasePoolPage::autoreleaseFast(id obj)
                          ├── id *add(id obj)
                          ├── static id *autoreleaseFullPage(id obj, AutoreleasePoolPage *page)
                          │     ├── AutoreleasePoolPage(AutoreleasePoolPage *newParent)
                          │     └── id *add(id obj)
                          └── static id *autoreleaseNoPage(id obj)
                                ├── AutoreleasePoolPage(AutoreleasePoolPage *newParent)
                                └── id *add(id obj)

無論走哪條路徑,最終都會匯入前面分析過的 autoreleaseFast。中間這幾層的實現非常樸素,只做了些參數判斷:

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;
}

小結

把整條鏈路收攏一下:

自動釋放池由一系列 AutoreleasePoolPage 以雙向鏈表串接而成,每頁 4096 字節,頁內是一個向高地址生長的棧;對象調用 autorelease 時被壓入這個棧;調用 AutoreleasePoolPage::pop 時,從棧頂向棧底依次發送 release,直到遇到哨兵對象為止。

理解了這套機制,再看 ARC 下的 @autoreleasepool 語法、以及為什麼 UI 操作必須回到主線程(主線程 RunLoop 每次迭代都包著一個自動釋放池),很多問題就自然清楚了。

參考資料

What is autoreleasepool? - Objective-C / Using Autorelease Pool Blocks / NSAutoreleasePool / 黑幕背後的 Autorelease

  1. 上一篇文章:
  2. 下一篇文章:
蘋果刷機越獄教程| IOS教程問題解答| IOS技巧綜合| IOS7技巧| IOS8教程
Copyright © IOS教程網 All Rights Reserved