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

Blocks 深度剖析:從語法糖到 __block、循環引用與底層結構體

編輯:iOS 開發綜合

一、Blocks 是什麼

Blocks 是 Apple 為 C 語言家族(Objective-C、C++)擴展出的一項能力,可以概括為一句話:帶有自動變量值的匿名函數。

所謂匿名,就是沒有名字。標準 C 並不允許定義這種函數:

int func(int count);
int result = func(10);

但如果換成函數指針,調用時確實可以不寫出函數名:

int func(int count);
int (*funcptr)(int) = &func;
int result = (*funcptr)(10);

Block 正是沿著這條路走下去的產物,只是它比函數指針多了一個關鍵能力:可以把外層作用域的局部變量一起「打包」帶走。

回顧一下 C 函數能觸碰的變量:自動變量(局部變量)、函數參數、靜態局部變量、靜態全局變量、全局變量。Block 在這份清單上又補了一塊:它把外層的自動變量以值的形式保存了下來。

二、Block 的語法

三種等價寫法,從完整到精簡:

^void (int i) { printf("%d", i); }   // 帶返回值類型與參數列表
^(int i) { printf("%d", i); }        // 省略返回值類型
^{ printf("123"); }                  // 無參數時參數列表也可省略

省略返回值類型時,編譯器會依據 block 體內 return 的表達式推導;沒有參數時,參數列表寫 void 或乾脆不寫都可以。

一個完整的聲明拆解如下:

int (^myBlock)(int) = ^(int num) { return num * num; };

逐段對照:int 是返回值類型(無返回值則為 void);(^myBlock) 中的 ^ 是 Block 的標記,myBlock 是變量名;第一個 (int) 是參數類型列表;^(int num) 是帶參數名的表達式開頭;大括號內則是 block 體,地位等同函數體。

三、Block 類型的變量

Block 變量的宣告方式與 C 的函數指針高度相似:

int f(int a) { return a; }
int (*fa)(int) = &f;              // 函數指針
int (^blk)(int) = ^(int a) { return a; };   // Block 變量

Block 變量之間可以互相賦值,也可以作為參數傳入函數、作為返回值傳出:

int (^blk1)(int) = blk;
int (^blk2)(int);
blk2 = blk1;
void func(int (^blk)(int)) { NSLog(@"%d", blk(1)); }

int (^makeIncrementer())(int) {
    return ^(int count) { return count + 1; };
}

可以明顯看出,一旦 Block 出現在參數與返回值位置,可讀性會急劇下降。解法與函數指針如出一轍——用 typedef 起個短名字:

typedef int (^blk_t)(int);

四、自動變量值的截獲:保存的是「瞬間值」

int myCount = 1;
int (^blk)(void) = ^{ NSLog(@"%d", myCount); return myCount; };
myCount++;
blk();
NSLog(@"%d", myCount);

輸出依次為 1 與 2。Block 在被定義的那一刻就複製了一份 myCount,此後外部怎麼改,Block 內看到的永遠是複製時的快照。這正是閉包的典型行為。

五、__block 修飾符:讓修改可以穿透

既然截獲的是值的副本,那麼在 Block 內直接賦值就會編譯失敗:

int val = 0;
void (^blk)(void) = ^{ val = 1; };   // 編譯錯誤

若確實需要在 Block 內改寫外層局部變量,必須在宣告時加上 __block:

__block int myCount = 1;
int (^blk)(void) = ^{ NSLog(@"%d", myCount); myCount = 4; return myCount; };
myCount++;
blk();
NSLog(@"%d", myCount);

此時輸出為 2 與 4——Block 內的賦值真正作用到了同一份存儲上。被 __block 修飾的變量,習慣上稱為 __block 變量。

幾點需要牢記的性質:

1. __block 是描述變量存儲類型的關鍵字,只對局部變量有意義,被它修飾的變量本質上仍在棧上;
2. 在其作用域內,所有 Block 共享同一份存儲空間;當 Block 被複製到堆上時,這份存儲不會隨作用域結束(退棧)而銷毀;
3. 出於優化考慮,棧上的 Block 一開始與普通棧變量無異,只有在執行 Block_copy 之後才真正拷貝到堆;
4. __block 變量不能是可變長數組。

六、截獲 Objective-C 對象時的「指針錯覺」

NSMutableArray *arr = [NSMutableArray array];
void (^blk)(void) = ^{ [arr addObject:@"1"]; };
blk();
NSLog(@"%@", arr);

輸出為包含 1 的數組,看起來像是「修改了外部變量」,實際上並沒有。arr 是一個保存內存地址的指針,Block 複製了這個指針,兩份指針指向同一塊堆內存。Block 內沒有改動指針本身,只是順著地址去操作對象——這是被允許的,所以外部也能看到變化。

換句話說,指針語義讓「值複製」的閉包看起來有了引用語義。而一旦你想讓指針本身(例如置為 nil)在 Block 內改動並向外傳播,仍然得靠 __block。

七、用 clang 把 Block 翻譯成 C++

Block 的實質是「帶有自動變量值的匿名函數」,但編譯之後它就不再是什麼神秘東西。clang(LLVM 前端)提供了 -rewrite-objc 選項,可以把含 Block 語法的源碼翻譯成可讀的 C++:

clang -rewrite-objc 源文件.m

以最簡單的例子出發:

int main() {
    void (^blk)(void) = ^{ printf("Block\n"); };
    blk();
    return 0;
}

翻譯後的核心結構大致如下(為便於閱讀做了排版整理):

struct __block_impl {
    void *isa;
    int Flags;
    int Reserved;
    void *FuncPtr;
};

struct __main_block_impl_0 {
    struct __block_impl impl;
    struct __main_block_desc_0 *Desc;
    __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int flags = 0) {
        impl.isa = &_NSConcreteStackBlock;
        impl.Flags = flags;
        impl.FuncPtr = fp;
        Desc = desc;
    }
};

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
    printf("Block\n");
}

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() {
    void (*blk)(void) = (void (*)())&__main_block_impl_0(
        (void *)__main_block_func_0, &__main_block_desc_0_DATA);
    ((void (*)(__block_impl *))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk);
    return 0;
}

幾個可以直接讀出的結論:

· Block 語法被翻譯成了一個普通的 C 函數 __main_block_func_0,命名規則是「所屬函數名 + Block 在該函數中出現的序號」。
· 參數 __cself 的地位等同 C++ 的 this 與 Objective-C 的 self,它是 Block 結構體的指針,用來在函數體內訪問被截獲的變量。
· 那個把 blk 變得看似複雜的強轉,拆開就一目了然:

struct __main_block_impl_0 tmp =
    __main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA);
struct __main_block_impl_0 *blk = &tmp;

也就是在棧上構造一個 Block 結構體實例,再把它的地址交給 blk。構造函數的第一個參數是 Block 對應的 C 函數指針,第二個是以靜態全局變量形式存在的描述結構體,其中 Block_size 記錄了實例大小,供後續複製到堆時使用。展開後的初始化結果是:

isa     = &_NSConcreteStackBlock;
Flags   = 0;
Reserved = 0;
FuncPtr = __main_block_func_0;
Desc    = &__main_block_desc_0_DATA;

八、__block 修飾符的底層形態

能改寫的變量大致分兩類。第一類是全局/靜態全局/靜態局部變量,它們位於數據區,Block 內可直接讀寫,翻譯後的 C 函數位於 Block 所屬函數之外,因此不受作用域限制。第二類就是 __block 變量。

__block 的書寫形式與 C 的存儲類說明符(typedef、extern、static、auto、register)並列,作用是指定變量存放在哪一塊存儲區域——auto 放棧,static 放數據區,而 __block 放進一個專門的結構體裡。

也就是說,Block 與 __block 變量在本質上都是「棧上的結構體實例」:Block 變成 Block 結構體的自動變量,__block 變量变成 __block 結構體的自動變量。

九、Block 的三種存儲域

Block 也是 Objective-C 對象,其 isa 指向三個不同的類之一:

· _NSConcreteStackBlock:實例位於棧上;
· _NSConcreteGlobalBlock:實例位於程序的數據區域(.data 段);
· _NSConcreteMallocBlock:實例位於 malloc 分配的堆內存中。

_NSConcreteGlobalBlock

void (^blk)(void) = ^{ printf("Global Block\n"); };

這個 Block 不截獲任何自動變量,內容不依賴運行時狀態,因此整個進程只需要一份實例,可以直接放進數據區域。判斷為 Global Block 的兩種情況:出現在全局變量位置;Block 表達式未使用任何被截獲的自動變量。

_NSConcreteStackBlock

NSArray *testArr = @[@"1", @"2"];
void (^TestBlock)(void) = ^{ NSLog(@"testArr : %@", testArr); };

凡是需要截獲自動變量的 Block,都是 Stack Block。換句話說,除 Global Block 之外的 Block 語法生成的都是棧上的 Block。

_NSConcreteMallocBlock:讓 Block 活得比作用域更久

棧上的 Block 與 __block 變量會隨作用域結束而銷毀。Blocks 的解法是把它們從棧複製到堆,這樣即使語法作用域結束,堆上的副本依然存在,此時 isa 被改寫為 _NSConcreteMallocBlock:

impl.isa = _NSConcreteMallocBlock;

把 Block 作為函數返回值時,ARC 下編譯器會自動插入複製代碼:

blk_t func(int rate) {
    return ^(int count) { return rate * count; };
}

大致被翻譯為:

blk_t func(int rate) {
    blk_t tmp = &__func_block_impl_0(__func_block_func_0,
                                    &__func_block_desc_0_DATA, rate);
    tmp = objc_retainBlock(tmp);            // 等同 _Block_copy:棧 → 堆
    return objc_autoreleaseReturnValue(tmp);
}

不同存儲域上調用 copy 的效果並不相同:

· Global Block(數據區域):什麼也不做;
· Stack Block(棧):從棧複製到堆;
· Malloc Block(堆):引用計數加一。

實踐中要牢記:Block_copy 等同 copy,Block_release 等同 release;無論 retain、copy 還是 release,retainCount 始終顯示為 1;Global Block 的三種操作全部無效;Stack Block 的 retain/release 無效,函數返回後內存即被回收,直接放進可變數組再取出會拿到野指針,正確做法是先 copy 到堆;Malloc Block 支持 retain/release,copy 不會產生新對象。一般來說,盡量不要對 Block 使用 retain。

十、__block 變量在複製過程中的歸屬

· 若 Block 原本在棧上,其使用的 __block 變量也在棧上,複製時兩者一併搬到堆,由該 Block 持有;此後再複製這個 Block,不會影響已持有的 __block 變量。
· 多個 Block 共用一個 __block 變量時,第一個搬到堆的 Block 會把變量一起搬過去並持有,後續搬遷的 Block 只是增加引用計數。
· 堆上的 Block 被釋放時,它持有的 __block 變量隨之釋放。

十一、什麼時候棧 Block 會被搬到堆

· 顯式調用 Block 的 copy 方法;
· Block 作為函數返回值返回;
· 把 Block 賦值給帶 __strong 修飾的 id 類型或 Block 類型成員變量;
· 向 Cocoa 框架中含有 usingBlock 的方法、或 GCD 的 API 傳遞 Block。

這幾種情況表面各異,本質上都歸結為 _Block_copy 被調用。反方向上,堆上的 Block 無人持有而被廢棄時會調用 dispose 函數,地位等同 dealloc。編譯器用標誌位 BLOCK_FIELD_IS_OBJECT 與 BLOCK_FIELD_IS_BYREF 區分截獲的是對象還是 __block 變量,並在 copy/dispose 中相應地持有與釋放。

十二、__block 修飾的對象類型變量

__block id obj = [[NSObject alloc] init];

clang 會生成一個專門的 byref 結構體:

struct __Block_byref_obj_0 {
    void *__isa;
    __Block_byref_obj_0 *__forwarding;
    int __flags;
    int __size;
    void (*__Block_byref_id_object_copy)(void *, void *);
    void (*__Block_byref_id_object_dispose)(void *);
    __strong id obj;
};

其中 __forwarding 的存在是為了在結構體從棧搬到堆之後,仍能透過原棧地址訪問到堆上的新副本——舊地址的 __forwarding 會指向新地址,形成一條轉發鏈。

ARC 下,__block 變量從棧複製到堆時由 _Block_object_assign 持有其中的對象,被廢棄時由 _Block_object_dispose 釋放。因此只要堆上的 __block 變量還在,其中的對象就一直處於被持有狀態,行為與直接截獲 __strong 對象一致。

十三、循環引用及其解法

Block 複製到堆後會強持有它截獲的對象,這是循環引用的溫床:

@interface MyObject : NSObject { blk_t blk_; }
@end

@implementation MyObject
- (id)init {
    self = [super init];
    blk_ = ^{ NSLog(@"self = %@", self); };
    return self;
}
@end

此時 self 持有 Block,Block 持有 self,dealloc 永遠不會被調用。即使 Block 內沒寫 self,只要訪問了成員變量 obj_,編譯後等同 self->obj_,一樣截獲了 self。

三種常見解法:

(1)用 __weak 打斷強引用鏈:

id __weak tmp = self;
blk_ = ^{ NSLog(@"self = %@", tmp); };

(2)用 __block 修飾臨時變量,並在 Block 執行完畢後主動置空:

__block id tmp = self;
blk_ = ^{ NSLog(@"self = %@", tmp); tmp = nil; };

這種寫法之所以成立,是因為 __block 變量本身不具強引用語義。但要注意:若 Block 一直不被執行,循環依然存在並導致洩露。

(3)__weak 與 __unsafe_unretained 的取捨。

__block 變量的優點在於:可以精確控制對象的持有區間;在不能使用 __weak 的環境下無需退而求其次用 __unsafe_unretained,也就不必擔心懸垂指針;並且在 Block 真正執行時可以動態決定要往變量裡放什麼。缺點也很明確:為了避免循環引用,必須確保 Block 會被執行。

總結一句:Blocks 讓我們能寫出更接近自然語言的異步代碼,但代價是必須時刻記住「誰持有誰」。理解 isa 的三種歸屬、copy 的觸發時機以及 __block 的 forwarding 機制,絕大多數 Block 相關的內存問題都能迎刃而解。

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