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

Blocks 實現原理(續):存儲域、__forwarding 與物件截獲

編輯:iOS 開發綜合

Block 與 __block 變量的本質

Block 和 __block 變量的實質,都是堆疊上的結構體實例。__block 變量本身就是堆疊上那個結構體的實例,而 Block 也是 Objective-C 的物件,其類別名為 _NSConcreteStackBlock。

這個類別並未出現在公開介面中,但執行期裡存在幾個類似的兄弟:

· _NSConcreteStackBlock——物件配置在堆疊上。

· _NSConcreteGlobalBlock——與全域變量相同,配置在程式的資料區域(.data)。

· _NSConcreteMallocBlock——物件配置在由 malloc 配置出的堆上。

什麼時候是 Global Block

前面看到的都是 stack block。但例如下面這種寫法:

void (^blk)(void) = ^{ printf("sdfs"); };
int main() { ... }

編譯後的初始化是 impl.isa = &_NSConcreteGlobalBlock;,也就是配置在資料區域。

原因很單純:使用全域變量的地方本來就不能存取自動變量,因此不存在「截獲自動變量」的行為;Block 結構體的內容不依賴執行期狀態,整個程式只需要一份實例,放在與全域變量相同的資料區域即可。

只有當 Block 截獲了自動變量 時,結構體內容才會隨執行期狀態變化。因此在以下兩種情況,Block 會是 _NSConcreteGlobalBlock:

1、在記述全域變量的地方使用 Block 語法。

2、Block 表達式中不使用任何需要截獲的自動變量。

除此之外產生的 Block 都是 _NSConcreteStackBlock,配置在堆疊上。

為什麼需要複製到堆上

配置在堆疊上的 Block 與 __block 變量,一旦所屬作用域結束就會被廢棄。Blocks 提供了把它們從堆疊複製到堆上的機制,使得語法描述的作用域結束後,堆上的 Block 仍能繼續存在。

複製到堆上後,會把 _NSConcreteMallocBlock 寫入結構體的 isa 成員:impl.isa = _NSConcreteMallocBlock;

__block 變量的 __forwarding 成員

Block 複製到堆上時,它所使用的 __block 變量也會一起從堆疊複製到堆。此時必須有辦法讓「堆疊上的 __block 變量」與「堆上的 __block 變量」指向同一份資料,這就是成員變量 __forwarding 存在的理由。

不論 __block 變量配置在堆疊還是堆上,都能正確存取到同一份值:只要堆疊上的結構體實例其 __forwarding 指向堆上的實例,那麼從兩邊出發都能抵達正確位置。這也解釋了為何即使 __block 變量已在堆上,仍可存取堆疊上的那一個。

ARC 下的自動複製

ARC 生效時,編譯器會自動判斷並插入複製程式碼。看這個函數:

typedef int (^blk_t)(int);

blk_t func(int rate) {
    return ^(int count){ return rate * count; };
}

它回傳的是配置在堆疊上的 Block。函數返回時作用域結束,堆疊上的 Block 理應被廢棄——這正是問題所在。但 ARC 編譯後的形式是:

blk_t func(int rate) {
    blk_t tmp = &__func_block_impl_0(__func_block_func_0, &__func_block_desc_0_DATA, rate);
    tmp = objc_retainBlock(tmp);
    return objc_autoreleaseReturnValue(tmp);
}

其中 objc_retainBlock 實際上就是 _Block_copy:把堆疊上的 Block 複製到堆,並將堆上的位址賦給 tmp;最後 objc_autoreleaseReturnValue 把堆上的 Block 當作 OC 物件註冊進 autoreleasepool 後回傳。因此當 Block 作為函數回傳值時,編譯器會自動產生複製到堆上的程式碼。

需要手動複製的情況

若使用 copy 實例方法,就必須自己寫出複製程式碼(alloc / new / copy / mutableCopy 中的 copy):

- (id)getBlockArray {
    int val = 10;
    return [[NSArray alloc] initWithObjects:
        ^{ NSLog(@"blk0:%d", val); },
        ^{ NSLog(@"blk1:%d", val); }, nil];
}

id obj = getBlockArray();
typedef void (^blk_t)(void);
blk_t blk = (blk_t)[obj objectAtIndex:0];
blk();   // 這裡會出錯,因為函數結束時堆疊上的 Block 已被廢棄

正確寫法是對每個 Block 呼叫 copy:

return [[NSArray alloc] initWithObjects:
    [^{ NSLog(@"blk0:%d", val); } copy],
    [^{ NSLog(@"blk1:%d", val); } copy], nil];

反之,當 Block 作為參數傳入方法或函數時,若該方法或函數內部已妥善複製了傳入的參數,呼叫端就不必事先手動複製。屬於這類的有:Cocoa 框架中方法名含 usingBlock 的方法,以及 Grand Central Dispatch 的 API。

重複呼叫 copy 會怎樣

blk = [[[[blk copy] copy] copy] copy];

堆疊上的 Block 第一次 copy 後已在堆上,後續的 copy 只是把同一個堆上位址再賦一次值,並不會產生新的實例。這裡的賦值過程都伴隨強引用的建立與失效,作用域結束時暫存變量 tmp 被廢棄、其強引用失效,但因 Block 仍被 blk 持有而不會被釋放。

__block 變量的存儲域

若一個 Block 使用了 __block 變量,當它從堆疊複製到堆時,所使用的 __block 變量也必定一起被複製。此時 Block 持有 __block 變量。

即使 Block 已複製到堆上,再對它 copy 也不會影響 __block 變量。

若多個 Block 使用同一個 __block 變量,第一個 Block 複製到堆後,其餘 Block 複製時也會持有該 __block 變量,並遞增其引用計數。

而當 Block 被廢棄時,它所持有的 __block 變量隨之釋放。

整套思考方式與 Objective-C 的引用計數式記憶體管理完全一致。

__forwarding 的必要性再確認

下面這段程式同時存取了堆疊與堆上的 __block 變量,卻能正確運作:

__block int val = 0;
void (^blk)(void) = [^{ ++val; } copy];
++val;
blk();
NSLog(@"%d", val);

這裡 ^{++val;} 是 Block 語法內的存取,++val; 則是語法外的一般存取,兩者都會被轉換成 ++(val.__forwarding->val);。當 __block 變量從堆疊複製到堆上時,堆疊上結構體的 __forwarding 會被替換為堆上結構體的位址。

如此一來,無論在 Block 語法內外、也無論 __block 變量配置在堆疊或堆上,都能存取到同一個變量。

截獲物件時的記憶體管理

blk_t blk;
{
    id array = [[NSMutableArray alloc] init];
    blk = [^(id obj) {
        [array addObject:obj];
        NSLog(@"array count = %ld", [array count]);
    } copy];
}
blk([[NSObject alloc] init]);
blk([[NSObject alloc] init]);
blk([[NSObject alloc] init]);

array 的作用域已結束、強引用失效,但程式執行完全正常——這說明賦值給 array 的 NSMutableArray 物件在超出其作用域後仍然存在。原因就在 Block 結構體中,被截獲的物件帶有 __strong 修飾符:

struct __main_block_impl_0 {
    struct __block_impl impl;
    struct __main_block_desc_0 *Desc;
    id __strong array;      // 強引用成員
};

static void __main_block_func_0(struct __main_block_impl_0 *__cself, id obj) {
    id __strong array = __cself->array;
    [array addObject:obj];
    NSLog(@"array count = %ld", [array count]);
}

static void __main_block_copy_0(struct __main_block_impl_0 *dst,
                                struct __main_block_impl_0 *src) {
    _Block_object_assign(&dst->array, src->array, BLOCK_FIELD_IS_OBJECT);
}

static void __main_block_dispose_0(struct __main_block_impl_0 *src) {
    _Block_object_dispose(src->array, BLOCK_FIELD_IS_OBJECT);
}

static struct __main_block_desc_0 {
    unsigned long reserved;
    unsigned long Block_size;
    void (*copy)(struct __main_block_impl_0*, struct __main_block_impl_0*);
    void (*dispose)(struct __main_block_impl_0*);
} __main_block_desc_0_DATA = {
    0,
    sizeof(struct __main_block_impl_0),
    __main_block_copy_0,
    __main_block_dispose_0
};

一般來說,C 結構體中不能含有帶 __strong 修飾符的成員,因為編譯器無從得知何時該初始化與廢棄。但 Objective-C 執行期能準確掌握「Block 從堆疊複製到堆」以及「堆上的 Block 被廢棄」這兩個時機,因此可以在 descriptor 中掛上 copy 與 dispose 函數,分別對強引用成員進行 retain 與 release。

copy 與 dispose 的呼叫時機

堆疊上的 Block 被複製到堆的時機有四種:

1、呼叫 Block 的 copy 實例方法時。

2、Block 作為函數回傳值回傳時。

3、把 Block 賦值給帶 __strong 修飾符的 id 型別或 Block 型別成員變量時。

4、在方法名含 usingBlock 的 Cocoa 框架方法或 GCD API 中傳遞 Block 時。

從原始碼角度看這四種情況各異,但最終都可歸結為 _Block_copy 被呼叫。相反地,堆上的 Block 不再被任何人持有而遭廢棄時,會呼叫 dispose 函數,其作用等同 dealloc。

物件截獲與 __block 變量的區別

兩者在 descriptor 中透過不同的旗標區分:

· 物件:BLOCK_FIELD_IS_OBJECT

· __block 變量:BLOCK_FIELD_IS_BYREF

但無論哪一種,copy 函數負責持有、dispose 函數負責釋放,機制是一致的。也正因為堆上的 Block 持有這些資源,它們才能超出原本的變量作用域而存在。

實務結論:在 Block 中使用物件型別自動變量時,除以下三種情況外,建議自行呼叫 copy——(1) Block 作為函數回傳值;(2) 賦值給帶 __strong 修飾符的 id 或 Block 型別成員變量;(3) 傳給方法名含 usingBlock 的 Cocoa 方法或 GCD API。ARC 環境下編譯器多數會代勞,但理解這層機制,才能解釋那些「物件為什麼沒被釋放」的循環引用問題。

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