您现在的位置: IOS教程網 >> IOS系統 >  >> iOS 程式開發 >> iOS 開發基礎

__block 修飾符的黑箱:用 clang 重寫看清底層機制

編輯:iOS 開發基礎

我們知道在 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 結構體實例,其中成員包含區域變量 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 存取該變量。

那為什麼這時候不能對 val 賦值?

因為 main 函數中的區域變量 val 與 __main_block_func_0 不在同一個作用域,呼叫過程只是進行了值傳遞。程式碼中我們可以用指標來修改區域變量——但那是由於呼叫 __main_block_func_0 時 main 的函式堆疊尚未展開完成,val 還在堆疊上。

然而在許多情況下,block 是作為參數傳遞、供後續回呼執行的。這些時候,block 被執行時,定義它所在的函式堆疊早已展開,區域變量已經不在堆疊中了(此時 block 在哪裡?),再用指標存取就……

所以,對於 auto 型別的區域變量,不允許 block 修改它是合理的。

__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 變量與循環引用

__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 才能解除循環引用,否則問題依然存在。

  1. 上一篇文章:
  2. 下一篇文章:
蘋果刷機越獄教程| IOS教程問題解答| IOS技巧綜合| IOS7技巧| IOS8教程
Copyright © IOS教程網 All Rights Reserved