Blocks 是 C 語言的擴充功能,Apple 在 OS X Snow Leopard 與 iOS 4 中正式引入。從那時起,Block 遍布 iOS 與 Mac 的各種 API,並被廣泛使用。一句話形容:Block 就是「帶有自動變量(區域變量)的匿名函數」。
Block 在 Objective-C 中的結構大致如下:
struct Block_layout {
void *isa;
int flags;
int reserved;
void (*invoke)(void *, ...);
struct Block_descriptor *descriptor;
/* Imported variables. */
};
struct Block_descriptor {
unsigned long int reserved;
unsigned long int size;
void (*copy)(void *dst, void *src);
void (*dispose)(void *);
};

從結構不難看到 isa——這說明 OC 是把 Block 當作物件來處理的。iOS 中常見的三種是 _NSConcreteStackBlock、_NSConcreteMallocBlock、_NSConcreteGlobalBlock(另外在 GC 環境下還有 _NSConcreteFinalizingBlock、_NSConcreteAutoBlock、_NSConcreteWeakBlockVariable 三種,本文暫不討論)。
接下來我們把焦點放在兩個問題上:Block 如何捕獲外部變量,以及 __block 的實現原理。
想看編譯器做了什麼,可以用 clang 把 Objective-C 源碼改寫成 C / C++:
clang -rewrite-objc block.c

先回顧 C 語言的變量分類,一般可分為五類:自動變量、函數參數、靜態變量、靜態全局變量、全局變量。研究 Block 的捕獲行為時排除函數參數,逐一驗證其餘四類。

把四類變量寫進同一段測試程式碼,編譯器立刻報錯:自動變量沒有加 __block。由於 __block 有點複雜,我們先只驗證靜態變量、靜態全局變量與全局變量這三類。
#importint global_i = 1; static int static_global_j = 2; int main(int argc, const char * argv[]) { static int static_k = 3; int val = 4; void (^myBlock)(void) = ^{ global_i++; static_global_j++; static_k++; NSLog(@"Block中 global_i = %d, static_global_j = %d, static_k = %d, val = %d", global_i, static_global_j, static_k, val); }; global_i++; static_global_j++; static_k++; val++; NSLog(@"Block外 global_i = %d, static_global_j = %d, static_k = %d, val = %d", global_i, static_global_j, static_k, val); myBlock(); return 0; }
執行結果:
Block外 global_i = 2, static_global_j = 3, static_k = 4, val = 5 Block中 global_i = 3, static_global_j = 4, static_k = 5, val = 4
兩個現象需要解釋:
__block 就不允許修改變量?用 clang 轉換一次源碼來看(原本 37 行、832 bytes 的 main.m,轉換後暴漲到 10 萬多行、3.1MB):
int global_i = 1;
static int static_global_j = 2;
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
int *static_k;
int val;
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc,
int *_static_k, int _val, int flags = 0)
: static_k(_static_k), val(_val) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
int *static_k = __cself->static_k; // bound by copy
int val = __cself->val; // bound by copy
global_i++;
static_global_j++;
(*static_k)++;
NSLog(..., global_i, static_global_j, (*static_k), val);
}
這兩個變量的值增加、並在 Block 內外都生效,很好理解:它們作用域廣、存放在全局區,Block 只是直接存取同一份記憶體,++ 之後的值自然會保留。
在 __main_block_impl_0 中可以看到,靜態變量 static_k 與自動變量 val 都被「搬」進來,成了這個結構體的成員變量;構造函數也多出了對應的兩個參數。
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc,
int *_static_k, int _val, int flags = 0)
: static_k(_static_k), val(_val)
初始化時是這樣傳入的:
void (*myBlock)(void) = ((void (*)())&__main_block_impl_0(
(void *)__main_block_func_0, &__main_block_desc_0_DATA, &static_k, val));
impl.isa = &_NSConcreteStackBlock;
impl.Flags = 0;
impl.FuncPtr = __main_block_func_0;
Desc = &__main_block_desc_0_DATA;
結論:執行 Block 表達式時,Block 用到的自動變量當下的值會被存進 Block 結構體實例中,也就是存進 Block 自己裡面。
順帶一提,如果外層還有很多自動變量、靜態變量,但 Block 內部完全沒用到,它們就不會被捕獲,也不會出現在構造函數的參數清單裡。Block 只捕獲閉包內真正會用到的變量。
再看 __main_block_func_0 的實現,編譯器自動加上的註解是 bound by copy:自動變量 val 雖然被捕獲,卻是以 __cself->val 的方式讀取。Block 只拿到了值,沒有拿到 val 的記憶體位址,所以即使在 Block 內改寫 val,也無法影響外層那個真正的 val。
Objective-C 很可能正是基於這一點,在編譯階段就直接擋掉開發者的誤用:
Variable is not assignable (missing __block type specifier)
小結一下第二個問題:自動變量以值傳遞的方式進入 Block 的構造函數;Block 只捕獲會用到的變量;因為只捕獲值而非位址,Block 內部無法改變自動變量。能被改變的是靜態變量、靜態全局變量與全局變量。
依照官方文件,蘋果的作法是:在自動變量前加上 __block 關鍵字(__block storage-class-specifier),就能在 Block 內改變外部自動變量。
於是在 Block 中改變變量值共有兩條路:傳入記憶體位址指標,或改變儲存區(__block)。
NSMutableString *str = [[NSMutableString alloc] initWithString:@"Hello,"];
void (^myBlock)(void) = ^{
[str appendString:@"World!"];
NSLog(@"Block中 str = %@", str);
};
NSLog(@"Block外 str = %@", str);
myBlock();
輸出:
Block外 str = Hello, Block中 str = Hello,World!
值確實被改變了。轉換源碼後可以看到,傳進結構體的是物件指標:
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
NSMutableString *str;
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc,
NSMutableString *_str, int flags = 0) : str(_str) { ... }
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
NSMutableString *str = __cself->str; // bound by copy
// 呼叫 appendString:
}
至於源碼裡多出來的 copy 與 dispose,下一節再說。

沒用到外部變量是 GlobalBlock 很好理解;但「只用到全局變量、靜態變量」同樣屬於 GlobalBlock:
void (^myBlock)(void) = ^{
NSLog(@"Block中 變量 = %d %d %d", static_global_j, static_k, global_i);
};
NSLog(@"%@", myBlock);
輸出:
<__NSGlobalBlock__: 0x100001050> Block中 變量 = 2 3 1
所以在 ARC 環境下,三種類型都可以捕獲外部變量。
StackBlock 不持有物件(以下在 MRC 下執行):
NSObject *obj = [[NSObject alloc] init];
NSLog(@"1.Block外 obj = %lu", (unsigned long)obj.retainCount);
void (^myBlock)(void) = ^{
NSLog(@"Block中 obj = %lu", (unsigned long)obj.retainCount);
};
NSLog(@"2.Block外 obj = %lu", (unsigned long)obj.retainCount);
myBlock();
輸出:retainCount 全程為 1。
MallocBlock 持有物件:
void (^myBlock)(void) = [^{
NSLog(@"Block中 obj = %lu", (unsigned long)obj.retainCount);
} copy];
輸出:Block 外 1 → 2 → Block 中 2 → release 後回到 1。
GlobalBlock 不持有物件:Block 內部自行建立的物件,retainCount 為 1。
由於 StackBlock 所屬的作用域一結束就會被銷毀,ARC 下編譯器會自動把 Block 從棧複製到堆。以下四種情況系統會自動 copy:
__strong 或 id 類型)但當 Block 是函數參數時,就需要自己手動 copy 到堆上(GCD 等系統 API 除外)。
#define Block_copy(...) ((__typeof(__VA_ARGS__))_Block_copy((const void *)(__VA_ARGS__))) #define Block_release(...) _Block_release((const void *)(__VA_ARGS__))
_Block_copy_internal 完成了 StackBlock 到 MallocBlock 的轉換,可以拆成幾個關鍵步驟:
static void *_Block_copy_internal(const void *arg, const int flags) {
struct Block_layout *aBlock;
const bool wantsOne = (WANTS_ONE & flags) == WANTS_ONE;
if (!arg) return NULL;
aBlock = (struct Block_layout *)arg;
// 已在堆上:增加引用計數後直接返回
if (aBlock->flags & BLOCK_NEEDS_FREE) {
latching_incr_int(&aBlock->flags);
return aBlock;
}
// 全局 Block:直接返回,不需要複製
else if (aBlock->flags & BLOCK_IS_GLOBAL) {
return aBlock;
}
// 配置堆記憶體並逐位元搬移
struct Block_layout *result = malloc(aBlock->descriptor->size);
if (!result) return (void *)0;
memmove(result, aBlock, aBlock->descriptor->size);
result->flags = ~(BLOCK_REFCOUNT_MASK);
result->flags |= BLOCK_NEEDS_FREE | 1;
result->isa = _NSConcreteMallocBlock;
// 若有 copy/dispose,則修正物件欄位
if (result->flags & BLOCK_HAS_COPY_DISPOSE) {
(*aBlock->descriptor->copy)(result, aBlock);
}
return result;
}
_Block_release 則負責銷毀:先遞減引用計數,若還有剩就直接返回;否則依標記決定是呼叫 dispose 並釋放記憶體,還是什麼都不做(GlobalBlock)。對棧上的 Block 呼叫 release 只會印出警告並忽略。
回到字串那個例子,轉換後的 __main_block_desc_0 多了兩個成員:
static void __main_block_copy_0(struct __main_block_impl_0 *dst,
struct __main_block_impl_0 *src) {
_Block_object_assign((void*)&dst->str, (void*)src->str, 3 /*BLOCK_FIELD_IS_OBJECT*/);
}
static void __main_block_dispose_0(struct __main_block_impl_0 *src) {
_Block_object_dispose((void*)src->str, 3 /*BLOCK_FIELD_IS_OBJECT*/);
}
原因是:C 結構體本身無法很好地處理初始化與銷毀,對記憶體管理不利。於是編譯器在 descriptor 中插入 copy 與 dispose 兩個函式指標,藉 Objective-C Runtime 完成記憶體管理。這裡的 _Block_object_assign 與 _Block_object_dispose 就對應 retain 與 release。
而 BLOCK_FIELD_IS_OBJECT 是 Block 截獲物件時的標記;若截獲的是 __block 變量,標記會變成 BLOCK_FIELD_IS_BYREF。
__block int i = 0;
void (^myBlock)(void) = ^{
i++;
NSLog(@"%d", i);
};
myBlock();
轉換後的源碼:
struct __Block_byref_i_0 {
void *__isa;
__Block_byref_i_0 *__forwarding;
int __flags;
int __size;
int i;
};
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
__Block_byref_i_0 *i; // by ref
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc,
__Block_byref_i_0 *_i, int flags = 0)
: i(_i->__forwarding) { ... }
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
__Block_byref_i_0 *i = __cself->i; // bound by ref
(i->__forwarding->i)++;
NSLog(..., (i->__forwarding->i));
}
帶 __block 的變量同樣被轉化成一個結構體,共五個成員:isa 指標、指向自身類型的 __forwarding 指標、flag 標記、自身大小,以及與變量同名的值。初始化時 __forwarding 傳入的是自己的位址:
__attribute__((__blocks__(byref))) __Block_byref_i_0 i =
{(void*)0, (__Block_byref_i_0 *)&i, 0, sizeof(__Block_byref_i_0), 0};
做個實驗(MRC 環境),把 Block copy 到堆上之後,再印出 Block 內外的 &i:
__block int i = 0;
NSLog(@"%p", &i);
void (^myBlock)(void) = [^{
i++;
NSLog(@"這是Block裡面 %p", &i);
} copy];
輸出:
0x7fff5fbff818 <__NSMallocBlock__: 0x100203cc0> 這是Block裡面 0x1002038a8
兩者相差 1052 位元組,說明 __forwarding 已經不再指向原來的自己了。原因就在於 Block 被 copy 到堆上:堆上的 Block 會持有它捕獲的物件,也會複製一份 __block 變量;當 Block 釋放時,若沒有其他引用,這份 __block 也會一起被銷毀。
__forwarding 的作用於此明朗:原本它指向自己,Block 被複製到堆上後,改成指向堆上那份複製出來的自己;而堆上變量的 __forwarding 再指向它自己。如此一來,不論 __block 在堆上還是棧上,都能透過 (i->__forwarding->i) 正確取到值。

如果 Block 沒有被 copy(以下 MRC 環境):
__block int i = 0;
NSLog(@"%p", &i);
void (^myBlock)(void) = ^{ i++; NSLog(@"Block裡面的 %p", &i); };
NSLog(@"%@", myBlock);
myBlock();
輸出:
0x7fff5fbff818 <__NSStackBlock__: 0x7fff5fbff7c0> 0x7fff5fbff818
Block 捕獲 __block 變量後並未複製到堆上,位址始終留在棧上,__forwarding 也只指向自己。
而在 ARC 環境下,只要 Block 有賦值動作就會觸發 copy,__block 幾乎都會被複製到堆上,Block 也成為 __NSMallocBlock。不過 ARC 下依然存在 __NSStackBlock——例如下面這種沒有賦值、直接建立並呼叫的寫法:
__block int temp = 10;
NSLog(@"%@", ^{ NSLog(@"*******%d %p", temp++, &temp); });
輸出:
<__NSStackBlock__: 0x7fff5fbff768>
之所以平時最常見到 MallocBlock,是因為我們通常會把 Block 賦值給變量,而 ARC 下透過 = 傳遞會觸發 objc_retainBlock → _Block_copy → _Block_copy_internal 這條呼叫鏈,使 StackBlock 轉為 MallocBlock。
// ARC 環境
__block id block_obj = [[NSObject alloc] init];
id obj = [[NSObject alloc] init];
NSLog(@"block_obj = [%@ , %p] , obj = [%@ , %p]", block_obj, &block_obj, obj, &obj);
void (^myBlock)(void) = ^{
NSLog(@"***Block中****block_obj = [%@ , %p] , obj = [%@ , %p]",
block_obj, &block_obj, obj, &obj);
};
myBlock();
輸出:
block_obj = [<NSObject: 0x100b027d0> , 0x7fff5fbff7e8] , obj = [<NSObject: 0x100b03b50> , 0x7fff5fbff7b8] Block中 block_obj = [<NSObject: 0x100b027d0> , 0x100f000a8] , obj = [<NSObject: 0x100b03b50> , 0x100f00070]
轉換後可以看到,__Block_byref_block_obj_0 比非物件版本多了兩個函式指標 __Block_byref_id_object_copy 與 __Block_byref_id_object_dispose,負責該物件在複製與銷毀時的記憶體管理。
另外要記住:OC 中物件變量預設自帶 __strong 修飾符,因此
__block id block_obj = [[NSObject alloc] init]; id obj = [[NSObject alloc] init];
等價於
__block id __strong block_obj = [[NSObject alloc] init]; id __strong obj = [[NSObject alloc] init];
從打印結果看,ARC 下 Block 捕獲外部物件變量時兩者位址都不同(都複製了一份),差別只在於帶 __block 的變量會被 Block 內部持有。
同樣的程式碼放到 MRC 下執行,Block 內外的位址完全相同——此時 Block 是 __NSStackBlock__,retainCount 都是 1;一旦 copy 成 __NSMallocBlock__,retainCount 才變成 2。
回到開頭的五類變量。嚴格來說,只有自動變量與靜態變量會成為 __main_block_impl_0 的成員變量,也就是真正被「捕獲」;捕獲進來的物件會被 Block 持有。
非物件變量方面:
__block 的自動變量,值被 copy 進 Block,只能讀取不能修改。__block 的自動變量與靜態變量,是直接位址存取,因此可以在 Block 內改值。

物件方面:MRC 下 __block 不會對指標指向的物件執行 copy,只是複製指標;ARC 下,宣告為 __block 的外部物件會在 Block 內部被 retain,以確保 Block 執行期間能安全引用外部物件——這也正是循環引用問題的根源。
把「捕獲變量」與「持有變量」這兩個概念分清楚,後續處理 Block 循環引用時才不會靠猜。
本文最初版本對 ARC 下 StackBlock 的說明不夠嚴謹,感謝 @酷酷的哀殿 指正、@bestswifter 指點,已在文中更新。