iOS開發筆記（七）：深刻理解 Autorelease

時間  2019-12-06
標籤 ios 開發 筆記 深刻 理解 autorelease 欄目 iOS 简体版
原文   原文鏈接

Autorelease 機制是 iOS 開發者管理對象內存的好夥伴，MRC中，調用 [obj autorelease] 來延遲內存的釋放是一件簡單天然的事，ARC下，咱們甚至能夠徹底不知道 Autorelease 就能管理好內存。而在這背後，objc 和編譯器都幫咱們作了哪些事呢，它們是如何協做來正確管理內存的呢？刨根問底，一塊兒來探究下黑幕背後的 Autorelease 機制。objective-c

1.Autoreleased 對象什麼時候被釋放

autorelease 本質上就是延遲調用 release，那 autoreleased 對象究竟會在何時釋放呢？如下咱們來作一個實驗。app

特別說明：在蘋果一些新的硬件設備上，本實驗的結果已經再也不成立，詳細狀況以下：框架

  • iPad 2less

  • iPad Air函數

  • iPad Air 2oop

  • iPad Propost

  • iPad Retina測試

  • iPhone 4sui

  • iPhone 5this

  • iPhone 5s

  • iPhone 6

  • iPhone 6 Plus

  • iPhone 6s

  • iPhone 6s Plus

    __weak NSString *string_weak_ = nil;
  - (void)viewDidLoad {
  	[super viewDidLoad];

  	// 場景 1
  	NSString *string = [NSString stringWithFormat:@"leichunfeng"];
  	string_weak_ = string;

  	// 場景 2
  //    @autoreleasepool {
  //        NSString *string = [NSString stringWithFormat:@"leichunfeng"];
  //        string_weak_ = string;
  //    }

  	// 場景 3
  //    NSString *string = nil;
  //    @autoreleasepool {
  //        string = [NSString stringWithFormat:@"leichunfeng"];
  //        string_weak_ = string;
  //    }

  	NSLog(@"string: %@", string_weak_);
  }

  - (void)viewWillAppear:(BOOL)animated {
  	[super viewWillAppear:animated];
  	NSLog(@"string: %@", string_weak_);
  }

  - (void)viewDidAppear:(BOOL)animated {
  	[super viewDidAppear:animated];
  	NSLog(@"string: %@", string_weak_);
  }
複製代碼

    讓咱們一塊兒來看看 console 輸出：

    // 場景 1
  2015-05-30 10:32:20.837 AutoreleasePool[33876:1448343] string: leichunfeng
  2015-05-30 10:32:20.838 AutoreleasePool[33876:1448343] string: leichunfeng
  2015-05-30 10:32:20.845 AutoreleasePool[33876:1448343] string: (null)

  // 場景 2
  2015-05-30 10:32:50.548 AutoreleasePool[33915:1448912] string: (null)
  2015-05-30 10:32:50.549 AutoreleasePool[33915:1448912] string: (null)
  2015-05-30 10:32:50.555 AutoreleasePool[33915:1448912] string: (null)

  // 場景 3
  2015-05-30 10:33:07.075 AutoreleasePool[33984:1449418] string: leichunfeng
  2015-05-30 10:33:07.075 AutoreleasePool[33984:1449418] string: (null)
  2015-05-30 10:33:07.094 AutoreleasePool[33984:1449418] string: (null)
複製代碼

分析

3 種場景下，咱們都經過 [NSString stringWithFormat:@"leichunfeng"] 建立了一個 autoreleased 對象，這是咱們實驗的前提。而且，爲了可以在 viewWillAppear 和 viewDidAppear 中繼續訪問這個對象，咱們使用了一個全局的 __weak 變量 string_weak_ 來指向它。由於 __weak 變量有一個特性就是它不會影響所指向對象的生命週期，這裏咱們正是利用了這個特性。

場景 1

當使用 [NSString stringWithFormat:@"leichunfeng"] 建立一個對象時，這個對象的引用計數爲 1，而且這個對象被系統自動添加到了當前的 autoreleasepool 中。當使用局部變量 string 指向這個對象時，這個對象的引用計數 +1 ，變成了 2。由於在 ARC 下 NSString *string 本質上就是 __strong NSString *string。因此在 viewDidLoad 方法返回前，這個對象是一直存在的，且引用計數爲 2。而當 viewDidLoad 方法返回時，局部變量 string 被回收，指向了 nil。所以，其所指向對象的引用計數 -1，變成了 1。

而在 viewWillAppear 方法中，咱們仍然能夠打印出這個對象的值，說明這個對象並無被釋放。不是一直都說當函數返回的時候，函數內部產生的對象就會被釋放的嗎？前面咱們提到了，這個對象是一個 autoreleased 對象，autoreleased 對象是被添加到了當前最近的 autoreleasepool 中了，只有當這個 autoreleasepool 自身 drain 的時候，autoreleasepool 中的 autoreleased 對象纔會被 release。

另外，咱們注意到當在 viewDidAppear 中再打印這個對象的時候，對象的值變成了 nil ，說明此時對象已經被釋放了。所以，咱們能夠大膽地猜想一下，這個對象必定是在 viewWillAppear 和 viewDidAppear 方法之間的某個時候被釋放了，而且是因爲它所在的 autoreleasepool 被 drain 的時候釋放的。

場景 2

同理，當經過 [NSString stringWithFormat:@"leichunfeng"] 建立一個對象時，這個對象的引用計數爲 1。而當使用局部變量 string 指向這個對象時，這個對象的引用計數 +1，變成了 2。而出了當前做用域時，局部變量 string 變成了 nil ，因此其所指向對象的引用計數變成 1。另外，咱們知道當出了 @autoreleasepool {} 的做用域時，當前 autoreleasepool 被 drain，其中的 autoreleased 對象被 release。因此這個對象的引用計數變成了 0，對象最終被釋放。

場景 3

同理，當出了 @autoreleasepool {} 的做用域時，其中的 autoreleased 對象被 release，對象的引用計數變成 1。當出了局部變量 string 的做用域，即 viewDidLoad 方法返回時，string 指向了 nil，其所指向對象的引用計數變成 0，對象最終被釋放。

總結

理解在這 3 種場景下，autoreleased 對象何時釋放對咱們理解 Objective-C 的內存管理機制很是有幫助。其中，場景 1 出現得最多，就是不須要咱們手動添加 @autoreleasepool {} 的狀況，直接使用系統維護的 autoreleasepool ；場景 2 就是須要咱們手動添加 @autoreleasepool {} 的狀況，手動干預 autoreleased 對象的釋放時機；場景 3 是爲了區別場景 2 而引入的，在這種場景下並不能達到出了 @autoreleasepool {} 的做用域時 autoreleased 對象被釋放的目的。

注意：不要混淆 autoreleasepool 與 @autoreleasepool {}

2.AutoreleasePool 與 RunLoop

首先咱們明確什麼對象會自動加入 autoreleasepool ：

  • MRC 下須要對象調用 autorelease 纔會入池, ARC 下能夠經過 __autoreleasing 修飾符，不然的話看方法名，經過調用 alloc/new/copy/mutablecopy 之外的方法取得的對象，編譯器幫咱們自動加入 autoreleasepool (使用 alloc/new/copy/mutablecopy 方法進行初始化時，由系統管理對象，在適當的位置 release，不加入 autoreleasepool )。
  • 使用 array 會自動將返回對象註冊到 autoreleasepool。
  • __weak 修飾的對象，爲了保證在引用時不被廢棄，會註冊到 autoreleasepool 中。
  • id 的指針或對象的指針，在沒有顯式指定時會被註冊到 autoreleasepool 中。

前面一節咱們講到，autoreleased 對象會被加到最近的 autoreleasepool 中，只有當這個 autoreleasepool 自身 drain 的時候，autoreleasepool 中的 autoreleased 對象纔會被 release (retainCount = 0 時對象釋放)。

那麼 autoreleasepool 是在何時釋放的呢。我的以爲有如下兩種狀況：

  • MRC 下顯式的調用 drain 方法。對於獲取不到的 NSAutoreleasePool 對象沒法操做，不是咱們討論的重點。

  • 在 runloop 開始時，都會隱式建立一個 autoreleasepool，並會在 runloop 結束時把前面建立的 autoreleasepool drain。

    AutoreleasePool 與 RunLoop

    程序運行 -> 開啓事件循環 -> 發生觸摸事件 -> 建立自動釋放池 -> 處理觸摸事件 -> 事件對象加入自動釋放池 -> 一次事件循環結束，銷燬自動釋放池

    至於 runloop 什麼時候結束就沒法肯定了。

    上面場景一中，因爲調用的非 alloc/new/copy/mutablecopy 方法取得對象，這個對象就自動被系統添加到了由主線程的 NSRunLoop 對象建立的 autoreleasepool 中，並在這個 autoreleasepool 被 drain 時獲得釋放。然而 runloop 什麼時候結束沒法肯定，咱們也不能顯式的調用 drain 方法，那有沒有好的解決辦法呢？幸運的是能夠。咱們可使用 NSAutoreleasepool 或 @autoreleasepool {}將對象加入到咱們建立的 autorelasepool 中，手動干預釋放 (如場景二)。

    之因此能夠這麼作確定和它的實現原理有關，下面咱們具體討論它的結構，相信你們看完確定能有本身的結論。

3.AutoreleasePool 的實現

3.1 從 main 函數開始

main 函數能夠說是在整個 iOS 開發中很是不起眼的一個函數，但倒是整個 iOS 應用的入口。

main.m 文件中的內容是這樣的：

int main(int argc, char * argv[]) {
    @autoreleasepool {
    	return UIApplicationMain(argc, argv, nil, NSStringFromClass([AppDelegate class]));
    }
}
複製代碼

在這個 @autoreleasepool block 中只包含了一行代碼，這行代碼將全部的事件、消息所有交給了 UIApplication 來處理，可是這不是本文關注的重點。

須要注意的是：整個 iOS 的應用都是包含在一個自動釋放池 block 中的。

3.2 @autoreleasepool

@autoreleasepool 究竟是什麼？咱們在命令行中使用使用如下命令讓編譯器從新改寫這個文件：

clang -x objective-c -rewrite-objc -isysroot /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator.sdk main.m
複製代碼

在生成了一大堆警告以後，當前目錄下多了一個 main.cpp 文件。在文件的最後，咱們能夠看到以下代碼：

int main(int argc, char * argv[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 
    	return UIApplicationMain(argc, argv, __null, NSStringFromClass(((Class (*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("AppDelegate"), sel_registerName("class"))));
    }
}
複製代碼

在這個文件中，有一個很是奇怪的 __AtAutoreleasePool 的結構體，前面的註釋寫到 /* @autoreleasepopl */。也就是說 @autoreleasepool {} 被轉換爲一個 __AtAutoreleasePool 結構體：

{
	__AtAutoreleasePool __autoreleasepool;
}
複製代碼

想要弄清楚這行代碼的意義，咱們要在 main.cpp 中查找名爲 __AtAutoreleasePool 的結構體：

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 只是幫助咱們少寫了這兩行代碼而已，讓代碼看起來更美觀。

4.AutoreleasePool 源碼解析

這一節開始分析方法 objc_autoreleasePoolPush 和 objc_autoreleasePoolPop 的實現：

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

void objc_autoreleasePoolPop(void *ctxt) {
    AutoreleasePoolPage::pop(ctxt);
}
複製代碼

上面的方法看上去是對 AutoreleasePoolPage 對應靜態方法 push 和 pop 的封裝。

這一小節會按照下面的順序逐步解析代碼中的內容：

  • AutoreleasePoolPage 的結構
  • objc_autoreleasePoolPush 方法
  • objc_autoreleasePoolPop 方法

4.1 AutoreleasePoolPage 的結構

AutoreleasePoolPage 是一個 C++ 中的類：

AutoreleasePoolPage

它在 NSObject.mm 中的定義是這樣的：

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 保存了當前頁所在的線程

每個自動釋放池都是由一系列的 AutoreleasePoolPage 組成的，而且每個 AutoreleasePoolPage 的大小都是 4096 字節(16 進制 0x1000)。

#define I386_PGBYTES 4096
#define PAGE_SIZE I386_PGBYTES
複製代碼

雙向鏈表

自動釋放池中的 AutoreleasePoolPage 是以雙向鏈表的形式鏈接起來的：

AutoreleasePoolPage-linked-list

parent 和 child 就是用來構造雙向鏈表的指針。

自動釋放池中的棧

若是咱們的一個 AutoreleasePoolPage 被初始化在內存的 0x100816000 ~ 0x100817000 中，它在內存中的結構以下：

page-in-memory

其中有 56 bit 用於存儲 AutoreleasePoolPage 的成員變量，剩下的 0x100816038 ~ 0x100817000 都是用來存儲加入到自動釋放池中的對象。

begin() 和 end() 這兩個類的實例方法幫助咱們快速獲取 0x100816038 ~ 0x100817000 這一範圍的邊界地址。

next 指向了下一個爲空的內存地址，若是 next 指向的地址加入一個 object，它就會以下圖所示移動到下一個爲空的內存地址中：

after-insert-to-page

關於 hiwat 和 depth 在文章中並不會進行介紹，由於它們並不影響整個自動釋放池的實現，也不在關鍵方法的調用棧中。

POOL_SENTINEL（哨兵對象）

到了這裏，你可能想要知道 POOL_SENTINEL 究竟是什麼，還有它爲何在棧中。

首先回答第一個問題： POOL_SENTINEL 只是 nil 的別名。

#define POOL_SENTINEL nil
複製代碼

在每一個自動釋放池初始化調用 objc_autoreleasePoolPush 的時候，都會把一個 POOL_SENTINEL push 到自動釋放池的棧頂，而且返回這個 POOL_SENTINEL 哨兵對象。

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

上面的 atautoreleasepoolobj 就是一個 POOL_SENTINEL。

而當方法 objc_autoreleasePoolPop 調用時，就會向自動釋放池中的對象發送 release 消息，直到第一個 POOL_SENTINEL：

pop-stack

4.2 objc_autoreleasePoolPush 方法

瞭解了 POOL_SENTINEL，咱們來從新回顧一下 objc_autoreleasePoolPush 方法：

void *objc_autoreleasePoolPush(void) {
    return AutoreleasePoolPage::push();
}
複製代碼

它調用 AutoreleasePoolPage 的類方法 push，也很是簡單：

static inline void *push() {
    return autoreleaseFast(POOL_SENTINEL);
}
複製代碼

在這裏會進入一個比較關鍵的方法 autoreleaseFast，並傳入哨兵對象 POOL_SENTINEL：

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->add(obj) 方法將對象添加至 AutoreleasePoolPage 的棧中

  • 有 hotPage 而且當前 page 已滿

    • 調用 autoreleaseFullPage 初始化一個新的頁
    • 調用 page->add(obj) 方法將對象添加至 AutoreleasePoolPage 的棧中

  • 無 hotPage

    • 調用 autoreleaseNoPage 建立一個 hotPage
    • 調用 page->add(obj) 方法將對象添加至 AutoreleasePoolPage 的棧中

最後的都會調用 page->add(obj) 將對象添加到自動釋放池中。

hotPage 能夠理解爲當前正在使用的 AutoreleasePoolPage。

page->add 添加對象

id *add(id obj) 將對象添加到自動釋放池頁中：

id *add(id obj) {
    id *ret = next;
    *next = obj;
    next++;
    return ret;
}
複製代碼

這個方法其實就是一個壓棧的操做，將對象加入 AutoreleasePoolPage 而後移動棧頂的指針。

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 開始遍歷整個雙向鏈表，直到：

  • 查找到一個未滿的 AutoreleasePoolPage
  • 使用構造器傳入 parent 建立一個新的 AutoreleasePoolPage

在查找到一個可使用的 AutoreleasePoolPage 以後，會將該頁面標記成 hotPage，而後調動上面分析過的 page->add 方法添加對象。

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

既然當前內存中不存在 AutoreleasePoolPage，就要從頭開始構建這個自動釋放池的雙向鏈表，也就是說，新的 AutoreleasePoolPage 是沒有 parent 指針的。

初始化以後，將當前頁標記爲 hotPage，而後會先向這個 page 中添加一個 POOL_SENTINEL 對象，來確保在 pop 調用的時候，不會出現異常。

最後，將 obj 添加到自動釋放池中。

4.3 objc_autoreleasePoolPop 方法

一樣，回顧一下上面提到的 objc_autoreleasePoolPop 方法：

void objc_autoreleasePoolPop(void *ctxt) {
    AutoreleasePoolPage::pop(ctxt);
}
複製代碼

看起來傳入任何一個指針都是能夠的，可是在整個工程並無發現傳入其餘對象的例子。不過在這個方法中傳入其它的指針也是可行的，會將自動釋放池釋放到相應的位置。

咱們通常都會在這個方法中傳入一個哨兵對象 POOL_SENTINEL，以下圖同樣釋放對象：

pop-stack

對 objc_autoreleasePoolPop 行爲的測試

在繼續分析這個方法以前作一個小測試，在 objc_autoreleasePoolPop 傳入非哨兵對象，測試一下這個方法的行爲。

下面是 main.m 文件中的源代碼：

#import <Foundation/Foundation.h>

int main(int argc, const char * argv[]) {
    @autoreleasepool {

        NSString *s = @"Draveness";
        [s stringByAppendingString:@"-Suffix"];

    }
    return 0;
}
複製代碼

在代碼的這一行打一個斷點，由於這裏會調用 autorelease 方法，將字符串加入自動釋放池：

breakpoint-main

當代碼運行到這裏時，經過 lldb 打印出當前 hotPage 中的棧內容：

print-pool-content

  • 經過 static 方法獲取當前 hotPage
  • 打印 AutoreleasePoolPage 中的內容
  • 打印當前 next 指針指向的內容，以及以前的內容，-2時已經到了 begin() 位置
  • 使用 print()和 printAll()打印自動釋放池中內容

而後將字符串 @"Draveness-Suffix" 的指針傳入 pop 方法，測試 pop 方法可否傳入非哨兵參數。

pop-string

再次打印當前 AutoreleasePoolPage 的內容時，字符串已經不存在了，這說明向 pop 方法傳入非哨兵參數是可行的，只是咱們通常不會傳入非哨兵對象。

讓咱們從新回到對 objc_autoreleasePoolPop 方法的分析，也就是 AutoreleasePoolPage::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 所在的 AutoreleasePoolPage

  • 調用 releaseUntil 方法釋放棧中的對象，直到 stop

  • 調用 child 的 kill 方法

    if (page->lessThanHalfFull()) {
      page->child->kill();
  } else if (page->child->child) {
      page->child->child->kill();
  }
複製代碼

pageForPointer 獲取 AutoreleasePoolPage

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 取模，獲得當前指針的偏移量，由於全部的 AutoreleasePoolPage 在內存中都是對齊的：

p = 0x100816048
p % SIZE = 0x48
result = 0x100816000
複製代碼

而最後調用的方法 fastCheck() 用來檢查當前的 result 是否是一個 AutoreleasePoolPage。

經過檢查 magic_t 結構體中的某個成員是否爲 0xA1A1A1A1。

releaseUntil 釋放對象

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() 方法

到這裏，沒有分析的方法就只剩下 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);
}
複製代碼

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

在 autorelease 方法的調用棧中，最終都會調用上面提到的 autoreleaseFast 方法，將當前對象加到 AutoreleasePoolPage 中。

這一小節中這些方法的實現都很是容易，只是進行了一些參數上的檢查，最終還要調用 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;
}
複製代碼

因爲在上面已經分析過 autoreleaseFast 方法的實現，這裏就不會多說了。

4.5 小結

整個自動釋放池 autoreleasepool 的實現以及 autorelease 方法都已經分析完了，咱們再來回顧一下文章中的一些內容：

  • 自動釋放池是由 AutoreleasePoolPage 以雙向鏈表的方式實現的。
  • 當對象調用 autorelease 方法時，會將對象加入 AutoreleasePoolPage 的棧中。
  • 調用 AutoreleasePoolPage::pop 方法會向棧中的對象發送 release 消息。

5.拾遺

5.1 NSAutoreleasePool

NSAutoreleasePool 是 Cocoa 用來支持引用計數內存管理機制的類，當一個 autorelease pool 被 drain 的時候會對 pool 裏的對象發送一條 release 的消息。(不能在 ARC 下使用)

使用方法以下：

NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
NSArray *array = [[[NSArray alloc] init] autorelease];
[pool drain];
複製代碼

5.2 AutoreleasePool 與線程

每個線程 (包括主線程) 都有一個 autoreleasepool 棧。當一個新的池子被建立的時候，push 進棧，當池子被釋放內存時，pop 出棧。對象調用 autorelease 方法進入棧頂的池子中。當線程結束的時候，它會自動地銷燬掉全部跟它有關聯的池子。

線程中的自動釋放池棧

5.3 容器的 block 版本的枚舉器

使用容器的 block 版本的枚舉器時，內部會自動添加一個 autoreleasepool：

[array enumerateObjectsUsingBlock:^(id obj, NSUInteger idx, BOOL *stop) {
// 這裏被一個局部@autoreleasepool包圍着
}];
複製代碼

固然，在普通 for 循環和 for in 循環中沒有，因此，仍是新版的 block 版本枚舉器更加方便。for 循環中遍歷產生大量 autorelease 變量時，就須要手加局部 autoreleasepool 咯。

5.4 何時用 AutoreleasePool

  • 寫基於命令行的程序時，就是沒有 UI 框架時，如 AppKit 等 Cocoa 框架。
  • 寫循環，循環裏面包含了大量臨時建立的對象。
  • 建立了新的線程。
  • 長時間在後臺運行的任務。

5.5 子線程默認不會開啓 Runloop，那出現 Autorelease 對象如何處理？不手動處理會內存泄漏嗎？

這一點請參考does NSThread create autoreleasepool automaticly now? 或 各個線程 Autorelease 對象的內存管理

6.參考

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程