提到 block 大家都不陌生,而記憶體管理是開發者最頭痛的部分。網上講 block 的文章很多,但多偏理論,這次我結合一些實例來說明。
根據 block 在記憶體中的位置,可以分成三類:
顧名思義:
__block 變數都會被銷毀。補充一點:在 ARC 開啟的情況下,只會有 NSConcreteGlobalBlock 與 NSConcreteMallocBlock 兩種類型。
講了這麼多理論,有人可能覺得這些跟自己無關——「我平時用 block 都沒問題啊」。那我們先來實際感受一次:
#import "ViewController.h"
void (^block)(void);
@implementation ViewController
- (void)viewDidLoad {
[super viewDidLoad];
NSInteger i = 10;
block = ^{
NSLog(@"%ld", i);
};
}
- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event {
block();
}
@end
這樣宣告一個 block,點擊螢幕時去呼叫它,就會出現錯誤:

典型的野指標錯誤。原因很明顯:這是一個產生在堆疊上的 block,超出作用域後已被釋放,此時再呼叫自然就崩了。列印這個 block 也能印證它是產生在堆疊上的:

有兩種做法。第一種是使用 Objective-C 為塊常數提供的 Block_copy() 與 Block_release() 函式,前者能把塊常數複製到堆上:
- (void)viewDidLoad {
[super viewDidLoad];
NSInteger i = 10;
block = Block_copy(^{
NSLog(@"%ld", i);
});
}
為了避免洩漏,Block_copy() 必須與 Block_release() 成對使用:
Block_release(block);
第二種是使用 Foundation 框架提供的 copy 與 release 方法,功能等同於上面兩個函式:
- (void)viewDidLoad {
[super viewDidLoad];
NSInteger i = 10;
block = ^{
NSLog(@"%ld", i);
} copy];
}
[block release];
這時可能有人會疑惑:為什麼我建的工程沒呼叫 copy 也沒報錯,還能正確列印?因為上面這些操作都是在 MRC 下進行的;在 ARC 下編譯器已經預設幫你執行了 copy。這也正好解釋了 block 超出變數作用域後仍能存在的原因。
接下來你可能會問:block 什麼時候在全域區、什麼時候在堆疊上、什麼時候在堆上?上面的例子是對堆疊上的 block 做 copy,那另外兩種做 copy 又是什麼情況?

這張表可以清楚看到三種 block 在 copy 之後各自發生了什麼,下面逐一來看。
在記述全域變數的位置使用 block 語法時,產生的就是 _NSConcreteGlobalBlock 類物件:
void (^block)(void) = ^ { NSLog(@"Global Block"); };
int main() { }
此外,當 block 表達式中沒有捕獲任何自動變數時,產生的 block 也在全域區:
int (^block)(int count) = ^(int count) {
return count;
};
block(2);
不過用 clang 改寫後的底層程式碼指向的卻是堆疊區:
impl.isa = _NSConcreteStackBlock
這裡引用一段說明:由於 clang 改寫的具體實作方式與 LLVM 不太一樣,而且這裡沒有開啟 ARC,所以看到的 isa 仍指向 _NSConcreteStackBlock;但在 LLVM 的實作中,開啟 ARC 時 block 應該是 _NSConcreteGlobalBlock 類型。
總結一下,產生在全域區的 block 有兩種情況:
配置在全域區的 block,即使從變數作用域外也能透過指標安全使用;但配置在堆疊上的 block,一旦作用域結束就會被銷毀。同理,__block 變數也配置在堆疊上,作用域結束後一樣會被銷毀。
上面那個例子就是產生在堆疊上的 block:
NSInteger i = 10;
block = ^{
NSLog(@"%ld", i);
};
除了配置在程式資料區的全域 block 之外,其餘產生的都是 _NSConcreteStackBlock 類物件,位於堆疊上。那麼堆上的 __NSConcreteMallocBlock 類什麼時候會用到?
Block 提供了把 block 與 __block 變數從堆疊複製到堆上的機制,這樣即使變數作用域結束,堆上的 block 依然存在。
impl.isa = _NSConcreteMallocBlock;
這就是 block 超出變數作用域後還能存在的原因。那堆疊上的 block 什麼時候會被複製到堆上?
__strong 修飾的 id 型別類或 block 型別成員變數時上面只講了 block;其實當使用 __block 變數的 block 從堆疊複製到堆上時,__block 變數本身也會被一起複製到堆上並由 block 持有。
再看一個例子:
void (^block)(void);
int main(int argc, const char * argv[]) {
@autoreleasepool {
__block NSInteger i = 10;
block = ^{
++i;
} copy];
++i;
block();
NSLog(@"%ld", i);
}
return 0;
}
我們對這個產生在堆疊上的 block 執行了 copy,於是 block 與 __block 變數都被複製到堆上。接著在 block 作用域之後,我們又操作了一個與 block 無關的變數:
++i;
一個存在於堆疊上,一個複製到了堆上,我們是如何做到都能正確存取的?用 clang 轉換原始碼來看:
struct __Block_byref_i_0 {
void *__isa;
__Block_byref_i_0 *__forwarding;
int __flags;
int __size;
NSInteger i;
};
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
__Block_byref_i_0 *i; // by ref
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_i_0 *_i, int flags=0) : i(_i->__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_i_0 *i = __cself->i; // bound by ref
++(i->__forwarding->i);
}
可以發現,相較於沒有 __block 修飾的變數,程式碼中多了一個名為 __Block_byref_i_0 的結構體,用來保存我們要捕獲並修改的變數 i。
在這個結構體裡可以看到成員變數 __forwarding,它持有指向該實例自身的指標。為什麼需要它?這正是關鍵所在。程式碼中有這麼一句:
++(i->__forwarding->i);
當堆疊上的 __block 變數被複製到堆上時,成員變數 __forwarding 的值會被替換為堆上那份結構體實例的位址。因此「不管 __block 變數配置在堆疊上還是堆上,都能正確存取該變數」——這就是 __forwarding 存在的意義。
循環引用的成因很簡單:物件與 block 互相強引用,導致誰都無法釋放,最終造成洩漏。基礎例子網上很多,這裡不重複,只討論一個實際被問過的問題:
block 裡使用 self 一定會造成循環引用嗎?
顯然不是。有些情況下可以直接用 self,例如呼叫系統的類方法:
[UIView animateWithDuration:0.5 animations:^{
NSLog(@"%@", self);
}];
因為這個 block 存在於靜態方法中,雖然 block 強引用了 self,但 self 並不持有這個靜態方法,所以完全可以在 block 內部使用 self。
還有一種情況:當 block 不是 self 的屬性時,self 並不持有這個 block,自然也不存在循環引用。
void (^block)(void) = ^() {
NSLog(@"%@", self);
};
block();
只要抓住循環引用的本質,這些判斷就不難理解。
希望透過這些例子,能讓大家對 block 有更深一層的認識——知其然,也知其所以然。