[轉]黑幕背後的__block修飾符

 

http://www.cocoachina.com/ios/20150106/10850.html

 

咱們知道在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纔可以解除循環引用問題，不然就會出現問題。