Block 和 __block 變量的實質,都是堆疊上的結構體實例。__block 變量本身就是堆疊上那個結構體的實例,而 Block 也是 Objective-C 的物件,其類別名為 _NSConcreteStackBlock。
這個類別並未出現在公開介面中,但執行期裡存在幾個類似的兄弟:
· _NSConcreteStackBlock——物件配置在堆疊上。
· _NSConcreteGlobalBlock——與全域變量相同,配置在程式的資料區域(.data)。
· _NSConcreteMallocBlock——物件配置在由 malloc 配置出的堆上。


前面看到的都是 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 複製到堆上時,它所使用的 __block 變量也會一起從堆疊複製到堆。此時必須有辦法讓「堆疊上的 __block 變量」與「堆上的 __block 變量」指向同一份資料,這就是成員變量 __forwarding 存在的理由。
不論 __block 變量配置在堆疊還是堆上,都能正確存取到同一份值:只要堆疊上的結構體實例其 __forwarding 指向堆上的實例,那麼從兩邊出發都能抵達正確位置。這也解釋了為何即使 __block 變量已在堆上,仍可存取堆疊上的那一個。
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。
blk = [[[[blk copy] copy] copy] copy];
堆疊上的 Block 第一次 copy 後已在堆上,後續的 copy 只是把同一個堆上位址再賦一次值,並不會產生新的實例。這裡的賦值過程都伴隨強引用的建立與失效,作用域結束時暫存變量 tmp 被廢棄、其強引用失效,但因 Block 仍被 blk 持有而不會被釋放。


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


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


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


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


整套思考方式與 Objective-C 的引用計數式記憶體管理完全一致。
下面這段程式同時存取了堆疊與堆上的 __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。
堆疊上的 Block 被複製到堆的時機有四種:
1、呼叫 Block 的 copy 實例方法時。
2、Block 作為函數回傳值回傳時。
3、把 Block 賦值給帶 __strong 修飾符的 id 型別或 Block 型別成員變量時。
4、在方法名含 usingBlock 的 Cocoa 框架方法或 GCD API 中傳遞 Block 時。
從原始碼角度看這四種情況各異,但最終都可歸結為 _Block_copy 被呼叫。相反地,堆上的 Block 不再被任何人持有而遭廢棄時,會呼叫 dispose 函數,其作用等同 dealloc。
兩者在 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 環境下編譯器多數會代勞,但理解這層機制,才能解釋那些「物件為什麼沒被釋放」的循環引用問題。