我們知道在Block使用中,Block內部能夠讀取外部局部變量的值。但我們需要改變這個變量的值時,我們需要給它附加上__block
修飾符。
__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
的結構體實例,其中__main_block_impl_0
結構體的成員包括局部變量val
。在__main_block_impl_0
結構體的構造方法中,val作爲第三個參數傳遞進入。
但執行我們的Block時,通過block
找到Block對應的方法執行部分__main_block_func_0
,並把當前block
作爲參數傳遞到__main_block_func_0
方法中。
__main_block_func_0
的第一個參數聲明如下:
struct __main_block_impl_0 *__cself
它和Objective-C的self相同,不過它是指向 __main_block_impl_0
結構體的指針。
這個時候我們就可以通過__cself->val
對該變量進行訪問。
那麼,爲什麼這個時候不能給val進行賦值呢?
因爲main函數中的局部變量val和函數__main_block_func_0不在同一個作用域中,調用過程中只是進行了值傳遞
。當然,在上面代碼中,我們可以通過指針來實現局部變量的修改。不過這是由於在調用__main_block_func_0時,main函數棧還沒展開完成,變量val還在棧中。但是在很多情況下,block是作爲參數傳遞以供後續回調執行的。通常在這些情況下,block被執行時,定義時所在的函數棧已經被展開,局部變量已經不在棧中了(block此時在哪裏?),再用指針訪問就……
所以,對於auto類型的局部變量,不允許block進行修改是合理的。
__block 到底是怎麼工作的?
我們把以下代碼通過 clang -rewrite-objc 源代碼文件名
重寫:
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就被廢棄。同樣地,__block
變量也分配在棧上,當超過該變量的作用域時,該__block變量也會被廢棄。
這個時候_NSConcreteMallocBlock
就登場了,Blocks提供了將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變量沒有持有者時,它纔會被廢棄。(這裏的思考方式和objc引用計數內存管理完全相同。)
而在棧上的__block變量被複制到堆上之後,會將成員變量__forwarding
的值替換爲堆上的__block變量的地址。這個時候我們可以通過以下代碼訪問:
val.__forwarding->val
如下面:
__block變量和循環引用問題
__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中。這個時候_block變量對 self
的強引用失效,從而避免循環引用的問題。使用__block變量的優點是:
- 通過__block變量可以控制對象的生命週期
- 在不能使用__weak修飾符的環境中,我們可以避免使用__unsafe_unretained修飾符
- 在執行Block時可動態地決定是否將nil或者其它對象賦值給__block變量
但是這種方法有一個明顯的缺點就是,我們必須去執行Block才能夠解除循環引用問題,否則就會出現問題。