下面兩行程式碼是等價的:
__block id obj = []; __block id __strong obj = [];
ARC 生效時,id 型別與物件型別變量必定會附加所有權修飾符,預設即為 __strong。看 clang 轉換後的結果:
// __block 變量用的結構體
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;
};
static void __Block_byref_id_object_copy_131(void *dst, void *src) {
_Block_object_assign((char *)dst + 40, *(void **)((char *)src + 40), 131);
}
static void __Block_byref_id_object_dispose_131(void *src) {
_Block_object_dispose(*(void **)((char *)src + 40), 131);
}
// __block 變量宣告部分
__Block_byref_obj_0 obj = {
0, &obj, 0x2000000, sizeof(__Block_byref_obj_0),
__Block_byref_id_object_copy_131,
__Block_byref_id_object_dispose_131,
[[NSObject alloc] init]
};
可見 __block 結構體中也掛了 copy / dispose 一對函數:Block 從堆疊複製到堆時,用 _Block_object_assign 持有 Block 所截獲的物件;堆上的 Block 被廢棄時,用 _Block_object_dispose 釋放。
blk_t blk;
{
id array = [[NSMutableArray alloc] init];
id __weak array2 = array;
blk = [^(id obj) {
[array2 addObject:obj];
NSLog(@"array2 count = %d", [array2 count]);
} copy];
}
blk([[NSObject alloc] init]);
blk([[NSObject alloc] init]);
blk([[NSObject alloc] init]);
執行結果全是 0。因為帶 __strong 修飾符的 array 在作用域結束時就被釋放廢棄,nil 會被賦值到帶 __weak 的 array2 中。
若同時加上 __block 與 __weak:
__block id __weak array2 = array;
結果仍然相同——即使附加了 __block 說明符,array 還是在作用域結束時被釋放,array2 仍會變成 nil。另外要注意,__autorelease 與 __block 一起使用會造成編譯錯誤。
當 Block 使用帶 __strong 修飾符的物件型別自動變量時,Block 從堆疊複製到堆後,該物件就為 Block 所持有。這很容易造成循環引用:
typedef void (^blk_t)(void);
@interface MyObject : NSObject {
blk_t blk_;
}
@end
@implementation MyObject
- (id)init {
self = [super init];
blk_ = ^{ NSLog(@"self = %@", self); };
return self;
}
- (void)dealloc { NSLog(@"dealloc"); }
@end
int main() {
id o = [[MyObject alloc] init];
NSLog(@"%@", o);
return 0;
}
這段程式碼中的 dealloc 永遠不會被呼叫。MyObject 物件透過成員變量 blk_ 持有 Block 的強引用,而 init 中的 Block 語法使用了帶 __strong 的 self,且 Block 被賦值到成員變量、已複製到堆上,因此 Block 持有了 self。self 持有 Block,Block 持有 self。


id __weak tmp = self;
blk_ = ^{ NSLog(@"self = %@", tmp); };
由於 Block 存在期間,持有該 Block 的 MyObject 物件(也就是賦值給 tmp 的 self)必定存在,因此不必額外判斷 tmp 是否為 nil。


@interface MyObject : NSObject {
blk_t blk_;
id obj_;
}
@end
@implementation MyObject
- (id)init {
self = [super init];
blk_ = ^{ NSLog(@"obj_ = %@", obj_); };
return self;
}
@end
Block 中雖然沒出現 self,卻同樣截獲了 self——因為 obj_ 實際上是 self->obj_ 的語法糖。解法相同:宣告 __weak 臨時變量。
typedef void (^blk_t)(void);
@interface MyObject : NSObject {
blk_t blk_;
}
@end
@implementation MyObject
- (id)init {
self = [super init];
__block id tmp = self;
blk_ = ^{
NSLog(@"self = %@", tmp);
tmp = nil; // 執行後斷開持有關係
};
return self;
}
- (void)execBlock { blk_(); }
- (void)dealloc { NSLog(@"dealloc"); }
@end
int main() {
id o = [[MyObject alloc] init];
[o execBlock];
return 0;
}
這樣並不會循環引用,但前提是必須執行 execBlock。若不執行 Block,循環依然存在並造成記憶體洩漏。


此時的持有鏈是:MyObject 物件 → 持有 Block → Block 持有 __block 變量 → __block 變量持有 MyObject 物件。
執行 execBlock 後,nil 被賦值給 __block 變量 tmp,__block 變量對 MyObject 的強引用失效,循環被打破。


__block 變量的優點:可以控制物件的持有時間;在不支援 __weak 的環境中,不必改用 __unsafe_unretained 即可解決。
__block 變量的缺點:必須執行 Block 才能斷開循環。若某條執行路徑不會跑到 Block,循環引用依然存在。
因此,當 Block 造成循環引用時,應依 Block 的用途來選擇:若生命周期明確、能保証 Block 一定會被執行完畢,用 __block 變量很合適;否則用 __weak 或 __unsafe_unretained 更穩妥。
此時必須手動把 Block 從堆疊複製到堆,並自行釋放,也就是使用 copy 與 release。
在 ARC 無效的環境中,__block 說明符反而被用來避免循環引用。原因是:Block 從堆疊複製到堆時,若使用的變量帶 __block 說明符,則不會被 retain;若沒有 __block 說明符,則會被 retain。
下面這段程式在 ARC 有效或無效時都會造成循環引用:
- (id)init {
self = [super init];
blk_ = ^{ NSLog(@"self = %@", self); };
return self;
}
改用 __block 變量即可避免:
__block id tmp = self;
blk_ = ^{ NSLog(@"self = %@", tmp); };
這也解釋了一個歷史現象:早期(非 ARC)的 iOS 程式碼中到處可見 __block id tmpSelf = self; 這種寫法,它並不是為了「讓變量可變」,而是為了斷開循環引用。ARC 到來後語義反轉,同样的寫法反而要用 __weak 才正確——閱讀老專案時,先確認 ARC 是否啟用,才能判斷眼前這段 __block 的意圖。