Block 是 Objective-C 中最容易被誤用的特性之一。很多開發者都遇過這樣的困惑:為什麼在 block 裡不能給局部變量賦值,卻可以往數組裡不停 addObject?本文從這一現象出發,把 block 的變量捕獲規則、循環引用陷阱與內存拷貝機制一次講透。
先看一段常見寫法:
NSMutableArray *mArray = [NSMutableArray arrayWithObjects:@"a", @"b", @"abc", nil];
NSMutableArray *mArrayCount = [NSMutableArray arrayWithCapacity:1];
[mArray enumerateObjectsWithOptions:NSEnumerationConcurrent usingBlock:^(id obj, NSUInteger idx, BOOL *stop) {
[mArrayCount addObject:[NSNumber numberWithInt:[obj length]]];
}];
答案藏在 Objective-C 的對象模型裡:OC 中的對象本質上都是指針。往數組裡添加或刪除元素,改變的是指針所指向的那塊堆內存,指針本身的地址並沒有發生變化。因此只要不對數組變量重新賦值(例如 mArrayCount = [NSMutableArray new];),任何對象內部的方法調用都是合法的。
歸納一下 block 對變量的訪問權限:
__block 修飾的變量,在 block 內可讀可寫。原理並不複雜:block 創建時會在棧上為它捕獲的局部變量保存一份拷貝,這份拷貝在 block 內部是常量,自然無法修改。若捕獲的是 OC 對象,block 會先 retain、執行完畢後再 release。而加上 __block 之後,變量會被包成一個結構體對象,block 持有的是指向該結構體的指針,因此可以改寫其成員值。
也正因為 __block 變量是可寫的共享狀態,它天生不是線程安全的。當你用 request 的 completionBlock 簡化回調代碼時,如果多個線程同時寫入同一個 __block 變量,就需要自己加鎖保護。
typedef void (^TestBlock)(void);
int val = 20;
TestBlock block1 = ^{ NSLog(@"%d", val); };
val = 50;
TestBlock block2 = ^{ NSLog(@"%d", val); };
val = 5;
TestBlock block3 = ^{ NSLog(@"%d", val); };
block1(); // 20
block2(); // 50
block3(); // 5
每個 block 在定義的那一刻就完成了對 val 的只讀拷貝,此後外部再怎麼改動 val,都與已生成的 block 無關。這就是「按值捕獲」的全部含義。
在避免循環引用的實踐中,我們常見到的兩種寫法:
// 無 ARC // __block id safeSelf = self; // 有 ARC __weak id safeSelf = self; // iOS 5 及更早 // __unsafe_unretained id safeSelf = self;
- (void)testAccessVariable
{
NSInteger outsideVariable = 10;
//__block NSInteger outsideVariable = 10;
NSMutableArray *outsideArray = [[NSMutableArray alloc] init];
void (^blockObject)(void) = ^(void){
NSInteger insideVariable = 20;
KSLog(@"> member variable = %d", self.memberVariable);
KSLog(@"> outside variable = %d", outsideVariable);
KSLog(@"> inside variable = %d", insideVariable);
[outsideArray addObject:@"AddedInsideBlock"];
};
outsideVariable = 30;
self.memberVariable = 30;
blockObject();
KSLog(@"> %d items in outsideArray", [outsideArray count]);
}
輸出結果:
> member variable = 30 > outside variable = 10 > inside variable = 20 > 1 items in outsideArray
注意 outsideVariable 依然是 10,即使它在 block 定義之後被改成了 30。成員變量 self.memberVariable 讀到的卻是 30,因為 block 捕獲的是 self,訪問的是實時的屬性值。若希望 block 內外共享同一份變量狀態,就必須加上 __block:
__block NSInteger outsideVariable = 10;
幾個容易踩坑的細節:
a) 往 outsideArray 添加元素是允許的,因為拷貝的是數組指針本身,操作的是同一個堆對象。
b) static 變量與全局變量在 block 中可讀寫,因為 block 內部拷貝的是指向這些變量的指針,而非變量值。
c) __block 變量的內部實現要複雜得多:它其實是一個結構體對象,block 拷貝的是指向該結構體的指針。
如果 block 是在方法外部定義後傳入的「獨立 block」,它無法直接捕獲調用方的 self,只能把 self 作為參數傳遞進來;此時訪問屬性也必須走 setter / getter,不能用點語法。而在方法內部就地定義的「內聯 block」不受此限制。
typedef NSString* (^IntToStringConverter)(id self, NSInteger paramInteger);
- (NSString *)convertIntToString:(NSInteger)paramInteger
usingBlockObject:(IntToStringConverter)paramBlockObject
{
return paramBlockObject(self, paramInteger);
}
typedef NSString* (^IntToStringInlineConverter)(NSInteger paramInteger);
- (NSString *)convertIntToStringInline:(NSInteger)paramInteger
usingBlockObject:(IntToStringInlineConverter)paramBlockObject
{
return paramBlockObject(paramInteger);
}
IntToStringConverter independentBlockObject = ^(id self, NSInteger paramInteger) {
KSLog(">> self %@, memberVariable %d", self, [self memberVariable]);
NSString *result = [NSString stringWithFormat:@"%d", paramInteger];
return result;
};
- (void)testAccessSelf
{
// 獨立 block:self 必須作為參數傳入
[self convertIntToString:20 usingBlockObject:independentBlockObject];
// 內聯 block:可直接引用 self
IntToStringInlineConverter inlineBlockObject = ^(NSInteger paramInteger) {
KSLog(">> self %@, memberVariable %d", self, self.memberVariable);
NSString *result = [NSString stringWithFormat:@"%d", paramInteger];
return result;
};
[self convertIntToStringInline:20 usingBlockObject:inlineBlockObject];
}
內聯 block 可以直接引用 self,但這正是循環引用的溫床。看一個通知註冊的例子:
@interface KSViewController ()
{
id _observer;
}
@end
@implementation KSViewController
- (void)viewDidLoad
{
[super viewDidLoad];
KSTester *tester = [[KSTester alloc] init];
[tester run];
_observer = [[NSNotificationCenter defaultCenter]
addObserverForName:@"TestNotificationKey"
object:nil
queue:nil
usingBlock:^(NSNotification *n) {
NSLog(@"%@", self);
}];
}
- (void)dealloc
{
if (_observer) {
[[NSNotificationCenter defaultCenter] removeObserver:_observer];
}
}
@end
看起來一切正常,實際上埋著兩個問題:
a) block 內引用了 self,於是 self 被 block retain;而 _observer 又持有這份 block 拷貝,通知中心再持有 _observer。只要 _observer 沒有解除註冊,block 就一直被通知中心持有,self 也就永遠不會釋放,dealloc 自然不會被調用——可我們偏偏指望在 dealloc 裡調用 removeObserver。這是一個死結。
b) _observer 由 self 所在的類賦值並持有,於是形成了 self → observer → block → self 的閉環。
蘋果官方對 addObserverForName:object:queue:usingBlock: 的說明寫得很清楚:
The block is copied by the notification center and (the copy) held until the observer registration is removed.
也就是說通知中心會拷貝 block 並持有該拷貝,直到註冊被移除。在 ARC 下,被拷貝的 block 無論是直接引用 self,還是通過引用 self 的成員變量間接引用,都會 retain self。
解法就是 WWDC 2011 Session 322(Objective-C Advancements in Depth)中介紹的 weak–strong dance:
__weak KSViewController *wself = self;
_observer = [[NSNotificationCenter defaultCenter]
addObserverForName:@"TestNotificationKey"
object:nil
queue:nil
usingBlock:^(NSNotification *n) {
KSViewController *sself = wself;
if (sself) {
NSLog(@"%@", sself);
} else {
NSLog(@"<self> dealloc before we could run this code.");
}
}];
為什麼這樣寫能奏效?拆成三步理解:
1. 在 block 之前建立 self 的弱引用 wself。弱引用不增加引用計數,self 釋放後它會自動變為 nil。
2. block 內部先用一個強引用 sself 去指向 wself。這一步至關重要:考慮到多線程場景,弱引用隨時可能失效,先在 block 內部「加固」一次,後續使用過程中 self 就不會被中途釋放。
3. 後續邏輯一律使用 sself,並且使用前必須做 nil 判斷——因為在 wself 賦值給 sself 的那一瞬間,self 可能已經被釋放了。
這樣 block 就不再持有 self,循環引用被打斷。
蘋果文檔提到:「run loops retain their timers, so you can release a timer after you have added it to a run loop.」而 scheduledTimerWithTimeInterval:target:selector:userInfo:repeats: 的 target 說明也寫明:The target object is retained by the timer and released when the timer is invalidated.
兩處結合可得結論:只要重複型 timer 還沒被 invalidate,target 就會被一直持有。所以當你把 self 當作 target 時,絕不能指望在 dealloc 裡 invalidate——timer 沒失效,dealloc 就永遠不會被調用。必須另找合適的時機(例如 viewDidDisappear)來 invalidate。
block 本質上也是一個 Objective-C 對象。在大多數情況下它分配在棧上;只有當 block 被定義為全局變量,或 block 內部沒有引用任何 automatic 變量時,才會分配在全局數據段。__block 變量同樣分配在棧上。
ARC 下編譯器會自動處理大部分 block 內存管理,但有一個例外:把 block 作為方法參數傳遞時,編譯器不會自動幫你拷貝。所幸 Cocoa 中介於名稱含「usingBlock」的接口以及 GCD 接口內部都已經做了 copy,不需要手動處理;除此之外的自定義場景則需要你介入。
- (id) getBlockArray
{
int val = 10;
return [[NSArray alloc] initWithObjects:
^{ KSLog("> block 0:%d", val); }, // 棧上的 block
^{ KSLog("> block 1:%d", val); }, // 棧上的 block
nil];
// 正確寫法:先 copy 到堆上
// return [[NSArray alloc] initWithObjects:
// [^{ KSLog("> block 0:%d", val); } copy],
// [^{ KSLog("> block 1:%d", val); } copy],
// nil];
}
- (void)testManageBlockMemory
{
id obj = [self getBlockArray];
typedef void (^BlockType)(void);
BlockType blockObject = (BlockType)[obj objectAtIndex:0];
blockObject();
}
執行上面這段代碼會 crash。原因很直白:返回的 block 分配在棧上,一旦超出定義它所在的作用域,棧幀被回收,block 也就失效了。正確做法(被註釋掉的那段)是在放入數組前先 copy 到堆上。
在 ARC 下,對 block 變量執行 copy 永遠是安全的:
如果棧上的 block 引用了 __block 變量,拷貝到堆上時,該 __block 變量也會一併拷貝到堆上(若堆上還沒有對應拷貝),否則只是增加堆上那份拷貝的引用計數。這也解釋了為什麼 __block 變量能在多個 block 之間真正共享同一份狀態。