本文主要介紹ARC下block的循環引用問題，舉例說明引起循環引用的場景和相應的解決方案。
在講block的循環引用問題之前，我們需要先了解一下iOS的內存管理機制和block的基本知識
iOS的內存管理機制
Objective-C在iOS中不支持GC(垃圾回收)機制，而是采用的引用計數的方式管理內存。
引用計數(Reference Count)
在引用計數中，每一個對象負責維護對象所有引用的計數值。當一個新的引用指向對象時，引用計數器就遞增，當去掉一個引用時，引用計數就遞減。當引用計數到零時，該對象就將釋放占有的資源。
我們通過開關房間的燈為例來?說明引用計數機制。
圖中，“需要照明的人數”即對應我們要說的引用計數值。
- 第一個人進入辦公室，“需要照明的人數”加1，計數值從0變為1，因此需要開燈；
- 之后每當有人進入辦公室，“需要照明的人數”就加1。如計數值從1變成2；
- 每當有人下班離開辦公室，“需要照明的人數”加減1如計數值從2變成1；
- 最后一個人下班離開辦公室時，“需要照明的人數”減1。計數值從1變成0，因此需要關燈。
在Objective-C中，”對象“相當于辦公室的照明設備，”對象的使用環境“相當于進入辦公室的人。上班進入辦公室的人對辦公室照明設備發出的動作，與Objective-C中的對應關系如下表
| 對照明設備所做的動作 | 對Objective-C對象所做的動作 |
|---|---|
| 開燈 | 生成對象 |
| 需要照明 | 持有對象 |
| 不需要照明 | 釋放對象 |
| 關燈 | 廢棄對象 |
使用計數功能計算需要照明的人數，使辦公室的照明得到了很好的管理。同樣，使用引用計數功能，對象也就能得到很好的管理，這就是Objective-C內存管理，如下圖所示
MRC(Manual Reference Counting)中引起應用計數變化的方法
| Objective-C對象方法 | 說明 |
|---|---|
| alloc/new/copy/mutableCopy | 創建對象，引用計數加1 |
| retain | 引用計數加1 |
| release | 引用計數減1 |
| dealloc | 當引用計數為0時調用 |
| [NSArray array] | 引用計數不增加，由自動釋放池管理 |
| [NSDictionary dictionary] | 引用計數不增加，由自動釋放池管理 |
自動釋放池
關于自動釋放，不是本文的重點，這里就不講了。
ARC(Automatic Reference Counting)中內存管理
| Objective-C對象所有權修飾符 | 說明 |
|---|---|
| __strong | 對象默認修飾符，對象強引用，在對象超出作用域時失效。其實就相當于retain操作，超出作用域時執行release操作 |
| __weak | 弱引用，不持有對象，對象釋放時會將對象置nil。 |
| __unsafe_unretained | 弱引用，不持有對象，對象釋放時不會將對象置nil。 |
| __autoreleasing | 自動釋放，由自動釋放池管理對象 |
block的基本知識
block的基本知識這里就不細說了，可以看看我的文章說說Objective-C中的block
循環引用問題
兩個對象相互持有，這樣就會造成循環引用，如下圖所示
圖中，對象A持有對象B，對象B持有對象A，相互持有，最終導致兩個對象都不能釋放。
block中循環引用問題
由于block會對block中的對象進行持有操作,就相當于持有了其中的對象，而如果此時block中的對象又持有了該block，則會造成循環引用。如下，
typedef void(^block)();
@property (copy, nonatomic) block myBlock;
@property (copy, nonatomic) NSString *blockString;
- (void)testBlock {
self.myBlock = ^() {
//其實注釋中的代碼，同樣會造成循環引用
NSString *localString = self.blockString;
//NSString *localString = _blockString;
//[self doSomething];
};
}
注：以下調用注釋掉的代碼同樣會造成循環引用，因為不管是通過self.blockString還是_blockString，或是函數調用[self doSomething]，因為只要 block中用到了對象的屬性或者函數，block就會持有該對象而不是該對象中的某個屬性或者函數。
當有someObj持有self對象，此時的關系圖如下。
當someObj對象release self對象時，self和myblock相互引用，retainCount都為1，造成循環引用
解決方法：
__weak typeof(self) weakSelf = self;
self.myBlock = ^() {
NSString *localString = weakSelf.blockString;
};
使用__weak修飾self，使其在block中不被持有，打破循環引用。開始狀態如下
當someObj對象釋放self對象時，Self的retainCount為0，走dealloc，釋放myBlock對象，使其retainCount也為0。
其實以上循環引用的情況很容易發現，因為此時Xcode就會報警告。而發生在多個對象間的時候，Xcode就檢測不出來了，這往往就容易被忽略。
//ClassB
@interface ClassB : NSObject
@property (strong, nonatomic) ClassA *objA;
- (void)doSomething;
@end
//ClassA
@property (strong, nonatomic) ClassB *objB;
@property (copy, nonatomic) block myBlock;
- (void)testBlockRetainCycle {
ClassB* objB = [[ClassB alloc] init];
self.myBlock = ^() {
[objB doSomething];
};
objB.objA = self;
}
解決方法：
- (void)testBlockRetainCycle {
ClassB* objB = [[ClassB alloc] init];
__weak typeof(objB) weakObjB = objB;
self.myBlock = ^() {
[weakObjB doSomething];
};
objB.objA = self;
}
將objA對象weak，使其不在block中被持有
注：以上使用__weak打破循環的方法只在ARC下才有效，在MRC下應該使用__block
或者，在block執行完后，將block置nil，這樣也可以打破循環引用
- (void)testBlockRetainCycle {
ClassB* objB = [[ClassB alloc] init];
self.myBlock = ^() {
[objB doSomething];
};
objA.objA = self;
self.myBlock();
self.myBlock = nil;
}
這樣做的缺點是，block只會執行一次，因為block被置nil了，要再次使用的話，需要重新賦值。
一些不會造成循環引用的block
在開發工程中，發現一些同學并沒有完全理解循環引用，以為只要有block的地方就會要用__weak來修飾對象，這樣完全沒有必要，以下幾種block是不會造成循環引用的。
大部分GCD方法
dispatch_async(dispatch_get_main_queue(), ^{
[self doSomething];
});
因為self并沒有對GCD的block進行持有，沒有形成循環引用。目前我還沒碰到使用GCD導致循環引用的場景，如果某種場景self對GCD的block進行了持有，則才有可能造成循環引用。
block并不是屬性值，而是臨時變量
- (void)doSomething {
[self testWithBlock:^{
[self test];
}];
}
- (void)testWithBlock:(void(^)())block {
block();
}
- (void)test {
NSLog(@"test");
}
這里因為block只是一個臨時變量，self并沒有對其持有，所以沒有造成循環引用
block使用對象被提前釋放
看下面例子，有這種情況，如果不只是ClassA持有了myBlock，ClassB也持有了myBlock。
當ClassA被someObj對象釋放后
此時，ClassA對象已經被釋放，而myBlock還是被ClassB持有，沒有釋放；如果myBlock這個時被調度，而此時ClassA已經被釋放，此時訪問的ClassA將是一個nil對象（使用__weak修飾，對象釋放時會置為nil），而引發錯誤。
另一個常見錯誤使用是，開發者擔心循環引用錯誤（如上所述不會出現循環引用的情況），使用__weak。比如
__weak typeof(self) weakSelf = self;
dispatch_async(dispatch_get_main_queue(), ^{
[weakSelf doSomething];
});
因為將block作為參數傳給dispatch_async時，系統會將block拷貝到堆上，而且block會持有block中用到的對象，因為dispatch_async并不知道block中對象會在什么時候被釋放，為了確保系統調度執行block中的任務時其對象沒有被意外釋放掉，dispatch_async必須自己retain一次對象（即self），任務完成后再release對象（即self）。但這里使用__weak，使dispatch_async沒有增加self的引用計數，這使得在系統在調度執行block之前，self可能已被銷毀，但系統并不知道這個情況，導致block執行時訪問已經被釋放的self，而達不到預期的結果。
注：如果是在MRC模式下，使用__block修飾self,則此時block訪問被釋放的self，則會導致crash。
該場景下的代碼
// ClassA.m
- (void)test {
__weak MyClass* weakSelf = self;
double delayInSeconds = 10.0f;
dispatch_time_t popTime = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(delayInSeconds * NSEC_PER_SEC));
dispatch_after(popTime, dispatch_get_main_queue(), ^(void){
NSLog(@"%@", weakSelf);
});
}
// ClassB.m
- (void)doSomething {
NSLog(@"do something");
ClassA *objA = [[ClassA alloc] init];
[objA test];
}
運行結果
[5988:435396] do something
[5988:435396] self:(null)
解決方法：
對于這種場景，就不應該使用__weak來修飾對象，讓dispatch_after對self進行持有，保證block執行時self還未被釋放。
block執行過程中對象被釋放
還有一種場景，在block執行開始時self對象還未被釋放，而執行過程中，self被釋放了，此時訪問self時，就會發生錯誤。
對于這種場景，應該在block中對 對象使用__strong修飾，使得在block期間對 對象持有，block執行結束后，解除其持有。
- (void)testBlockRetainCycle {
ClassA* objA = [[ClassA alloc] init];
__weak typeof(objA) weakObjA = objA;
self.myBlock = ^() {
__strong typeof(weakObjA) strongWeakObjA = weakObjA;
[strongWeakObjA doSomething];
};
objA.objA = self;
}
注：此方法只能保證在block執行期間對象不被釋放，如果對象在block執行執行之前已經被釋放了，該方法也無效。
