我們知道在 Block 中,內部可以讀取外部區域變量的值;但當我們想修改這個變量的值時,就得替它加上 __block 修飾符。
__block 另一個常見用途,是在某些情況下避免 Block 的循環引用——替相關物件加上 __block 修飾符即可。
把以下程式碼用 clang -rewrite-objc 檔案名稱 重寫:
int main(int argc, const char * argv[]) {
@autoreleasepool {
int val = 10;
void (^block)(void) = ^{
NSLog(@"%d", val);
};
block();
}
return 0;
}得到:
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
int val;
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _val, int flags=0) : 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 val = __cself->val; // bound by copy
NSLog((NSString *)&__NSConstantStringImpl__val_folders_gm_0jk35cwn1d3326x0061qym280000gn_T_main_41daf1_mi_0, val);
}
static struct __main_block_desc_0 {
size_t reserved;
size_t Block_size;
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0)};
int main(int argc, const char * argv[]) {
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
int val = 10;
void (*block)(void) = (void (^)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, val);
((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
}
return 0;
}可以注意到,Block 實質上被轉換成一個 __main_block_impl_0 結構體實例,其中成員包含區域變量 val;在該結構體的建構方法中,val 作為第三個參數傳入。
執行 Block 時,透過 block 找到對應的執行部分 __main_block_func_0,並把當前 block 作為參數傳進去。__main_block_func_0 的第一個參數宣告為:
struct __main_block_impl_0 *__cself
它相當於 Objective-C 的 self,只是指向 __main_block_impl_0 結構體。此時我們就能透過 __cself->val 存取該變量。
因為 main 函數中的區域變量 val 與 __main_block_func_0 不在同一個作用域,呼叫過程只是進行了值傳遞。程式碼中我們可以用指標來修改區域變量——但那是由於呼叫 __main_block_func_0 時 main 的函式堆疊尚未展開完成,val 還在堆疊上。
然而在許多情況下,block 是作為參數傳遞、供後續回呼執行的。這些時候,block 被執行時,定義它所在的函式堆疊早已展開,區域變量已經不在堆疊中了(此時 block 在哪裡?),再用指標存取就……
所以,對於 auto 型別的區域變量,不允許 block 修改它是合理的。
把以下程式碼同樣重寫:
int main(int argc, const char * argv[]) {
@autoreleasepool {
__block NSInteger val = 0;
void (^block)(void) = ^{
val = 1;
};
block();
NSLog(@"val = %ld", val);
}
return 0;
}可得到:
struct __Block_byref_val_0 {
void *__isa;
__Block_byref_val_0 *__forwarding;
int __flags;
int __size;
NSInteger val;
};
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
__Block_byref_val_0 *val; // by ref
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_val_0 *_val, int flags=0) : val(_val->__forwarding) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
__Block_byref_val_0 *val = __cself->val; // bound by ref
(val->__forwarding->val) = 1;
}
static void __main_block_copy_0(struct __main_block_impl_0 *dst, struct __main_block_impl_0 *src) {
_Block_object_assign((void*)&dst->val, (void*)src->val, 8 /*BLOCK_FIELD_IS_BYREF*/);
}
static void __main_block_dispose_0(struct __main_block_impl_0 *src) {
_Block_object_dispose((void*)src->val, 8 /*BLOCK_FIELD_IS_BYREF*/);
}
static struct __main_block_desc_0 {
size_t reserved;
size_t 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};
int main(int argc, const char * argv[]) {
{ __AtAutoreleasePool __autoreleasepool;
__attribute__((__blocks__(byref))) __Block_byref_val_0 val = {(void*)0,(__Block_byref_val_0 *)&val, 0, sizeof(__Block_byref_val_0), 0};
void (*block)(void) = (void (^)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_val_0 *)&val, 570425344);
((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
NSLog((NSString *)&__NSConstantStringImpl__val_folders_gm_0jk35cwn1d3326x0061qym280000gn_T_main_d7fc4b_mi_0, (val.__forwarding->val));
}
return 0;
}可以看到,被 __block 修飾的變量變成了一個 __Block_byref_val_0 結構體實例:
struct __Block_byref_val_0 {
void *__isa;
__Block_byref_val_0 *__forwarding;
int __flags;
int __size;
NSInteger val;
};注意這個結構體包含了對自身實例的引用 __forwarding。
而 Block 本身同樣被轉換成 __main_block_impl_0 結構體實例,該實例持有 __Block_byref_val_0 結構體實例的指標。
再看賦值與執行部分被轉化後的結果:
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
__Block_byref_val_0 *val = __cself->val; // bound by ref
(val->__forwarding->val) = 1;
}
((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);我們從 __cself 找到 __Block_byref_val_0 結構體實例,再透過該實例的 __forwarding 存取成員變量 val。val 是該實例自身持有的變量,指向原來的區域變量。如下圖:

上面展示了 __block 變量在 Block 中被讀取與修改的過程。那麼問題來了:
當 block 作為回呼執行時,區域變量 val 已經出堆疊了,這時程式碼為什麼還能正常運作?
我們為什麼要透過 __forwarding 而不是直接存取結構體中那個變量?__forwarding 被設計出來的理由是什麼?
由上面的描述可知,Block 與 __block 變量實質上就是對應結構體的實例。在轉換後的程式碼中可以看到,__main_block_impl_0 建構函數裡 isa 指向的是 _NSConcreteStackBlock。Block 還有另外兩個相似的類:
_NSConcreteStackBlock 保存在堆疊上的 block,出堆疊時會被銷毀
_NSConcreteGlobalBlock 全域的靜態 block,不存取任何外部變量
_NSConcreteMallocBlock 保存在堆上的 block,參考計數為 0 時才會被銷毀
上述範例中 Block 被設為 _NSConcreteStackBlock,在堆疊上產生。當我們把 Block 當成全域變量使用時,對應的 Block 會被設為 _NSConcreteGlobalBlock:
void (^block)(void) = ^{NSLog(@"This is a Global Block");};
int main(int argc, const char * argv[]) {
@autoreleasepool {
block();
}
return 0;
}該程式碼轉換後,Block 結構體的 isa 初始化為:
impl.isa = &_NSConcreteGlobalBlock;
那 _NSConcreteMallocBlock 何時會被使用?
分配在全域變量上的 Block,在變量作用域之外也能透過指標安全存取。但分配在堆疊上的 Block,一旦所屬變量的作用域結束就被廢棄;同樣地,__block 變量也分配在堆疊上,超過作用域時同樣會被廢棄。
這時 _NSConcreteMallocBlock 就登場了。Block 提供了把 Block 與 __block 變量從堆疊複製到堆上的方法來解決這個問題:把堆疊上的 Block 複製到堆上,這樣即使堆疊上的 Block 超過原本作用域,堆上的那份仍可繼續存在。
複製到堆上的 Block,其結構體成員 isa 會變成:
impl.isa = &_NSConcreteMallocBlock;
而 __block 變量結構體的成員 __forwarding 正是在此時發揮作用,保證從堆疊複製到堆上之後仍能正確存取 __block 變量。在這種情況下,只要堆疊上的 __block 變量的 __forwarding 指向堆上的實例,我們就能正確存取。
我們一般可以用 copy 方法手動把 Block 或 __block 變量從堆疊複製到堆上。比如把 Block 作為類的屬性時,我們通常把該屬性設為 copy。有些情況則不必手動複製,例如 Cocoa 框架中帶 usingBlock 的方法,或 GCD 的 API 傳遞 Block 時。
當一個 Block 被複製到堆上時,與之相關的 __block 變量也會被複製到堆上,此時堆上的 Block 持有對應的堆上 __block 變量。當堆上的 __block 變量沒有持有者時,它才會被廢棄。(這裡的思考方式與 Objective-C 參考計數記憶體管理完全相同。)
而在堆疊上的 __block 變量被複製到堆上之後,它的 __forwarding 會被替換為堆上那個 __block 變量的位址。此時可以透過以下程式碼存取:
val.__forwarding->val
如下圖:

__block 修飾符可以指定任何型別的區域變量。前面的轉換程式碼中有這一段:
static void __main_block_copy_0(struct __main_block_impl_0 *dst, struct __main_block_impl_0 *src) {
_Block_object_assign((void*)&dst->val, (void*)src->val, 8 /*BLOCK_FIELD_IS_BYREF*/);
}
static void __main_block_dispose_0(struct __main_block_impl_0 *src) {
_Block_object_dispose((void*)src->val, 8 /*BLOCK_FIELD_IS_BYREF*/);
}當 Block 從堆疊複製到堆上時,會用 _Block_object_assign 持有該變量(相當於 retain);當堆上的 Block 被廢棄時,則用 _Block_object_dispose 釋放它(相當於 release)。
由此可知,我們可以用下述程式碼解掉 Block 的循環引用:
__block id tmp = self;
void (^block)(void) = ^{
tmp = nil;
};
block();執行 block 後,nil 被賦值給 __block 變量 tmp,此時 tmp 對 self 的強引用失效,循環引用於是解除。使用 __block 變量的優點是:
可以控制物件的生命週期
在不能使用 __weak 的環境中,可以避免改用 __unsafe_unretained
執行 Block 時可動態決定要把 nil 或其他物件賦值給該變量
但這種方法有個明顯缺點:我們必須真的去執行 Block 才能解除循環引用,否則問題依然存在。