https://www.zhihu.com/question/280022939
1. 前言
有同學看到標題可能會疑惑，這個命題是正確的嗎？有些老開發或許還能清楚的記得以前遇到因為 Block 捕獲了 UI 對象，最后導致 UI 對象在子線程釋放從而導致 Crash 的問題。
沒錯，蘋果改了，我們先來做個試驗！
2. 測試
UI 對象現在確定是在主線程釋放了嗎？ 我們先構造一個簡單的 Demo 來看看:
// 構建 View
@interface TestView : UIView @end
@implementation TestView
- (void)test {}
- (void)dealloc
{
NSLog(@"dealloc view");
}
@end
// 構建一個 ViewController
@interface TestViewController : UIViewController
@end
@implementation TestViewController
- (void)test {}
- (void)dealloc
{
NSLog(@"dealloc viewController");
}
@end
// 在某個地方調用
TestView *view = [[TestView alloc] init];
TestViewController *vc = [[TestViewController alloc] init];
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_global_queue(0, 0), ^{
[view test];
[vc test];
});
然后我們分別在這兩個類的 dealloc 方法中打個斷點，發現都是在主線程釋放的。所以可以確定 UI 對象現在無論最后在哪個線程持有的，最終都會在主線程釋放
3. 調試分析
那么接下來就是調試一下看看這個調用鏈是什么樣的。
通過下圖的調試情況可以發現：
UIView/UIViewController 都單獨實現了
release方法，在release到需要 dealloc 的時候，會通過dispatch_barrier_async_f回到主線程調用_objc_deallocOnMainThreadHelper方法來實現釋放操作
到這里大概就知道是怎么做到回主線程釋放 UI 對象的了，但是還有個問題就是，這里是怎么判斷 release 到了 reatainCount 為 0 需要被釋放了呢
通過調試發現，就是讀取了 一個 UIView._retainCount 屬性來判斷的， 當 UIView._retainCount == 0 的時候，就回到主線程執行 dealloc 。
4 源碼查找
通過上面的分析，大概了解了流程，但是還是想清楚知道怎么做到的， 既然 ObjC 源碼開源的，我們就在 ObjC 源碼中搜索 _objc_deallocOnMainThreadHelper 和 dispatch_barrier_async_f 在 ObjC 源碼中看一下, 找到了這個宏：
- 1. 通過重寫
-retain``-release``-_tryRetain``-retainCount``-_isDeallocating等幾個方法來重寫內存管理 - 2. 使用一個新的ivar:
_rc_ivar來記錄retainCount，對應上面我們調試中的 UIView._retainCount。 然后通過__sync_fetch_and_add``__sync_fetch_and_sub等編譯指令實現原子訪問。
#define _OBJC_SUPPORTED_INLINE_REFCNT_LOGIC_BLOCK(_rc_ivar, _logicBlock) \
-(id)retain { \
/* this will fail to compile if _rc_ivar is an unsigned type */ \
int _retain_count_ivar_must_not_be_unsigned[0L - (__typeof__(_rc_ivar))-1] __attribute__((unused)); \
__typeof__(_rc_ivar) _prev = __sync_fetch_and_add(&_rc_ivar, 2); \
if (_prev < -2) { /* specifically allow resurrection from logical 0\. */ \
__builtin_trap(); /* BUG: retain of over-released ref */ \
} \
return self; \
} \
-(oneway void)release { \
__typeof__(_rc_ivar) _prev = __sync_fetch_and_sub(&_rc_ivar, 2); \
if (_prev > 0) { \
return; \
} else if (_prev < 0) { \
__builtin_trap(); /* BUG: over-release */ \
} \
_objc_object_disposition_t fate = _logicBlock(self); \
if (fate == _OBJC_RESURRECT_OBJECT) { \
return; \
} \
/* mark the object as deallocating. */ \
if (!__sync_bool_compare_and_swap(&_rc_ivar, -2, 1)) { \
__builtin_trap(); /* BUG: dangling ref did a retain */ \
} \
if (fate == _OBJC_DEALLOC_OBJECT_NOW) { \
[self dealloc]; \
} else if (fate == _OBJC_DEALLOC_OBJECT_LATER) { \
dispatch_barrier_async_f(dispatch_get_main_queue(), self, \
_objc_deallocOnMainThreadHelper); \
} else { \
__builtin_trap(); /* BUG: bogus fate value */ \
} \
} \
-(NSUInteger)retainCount { \
return (_rc_ivar + 2) >> 1; \
} \
-(BOOL)_tryRetain { \
__typeof__(_rc_ivar) _prev; \
do { \
_prev = _rc_ivar; \
if (_prev & 1) { \
return 0; \
} else if (_prev == -2) { \
return 0; \
} else if (_prev < -2) { \
__builtin_trap(); /* BUG: over-release elsewhere */ \
} \
} while ( ! __sync_bool_compare_and_swap(&_rc_ivar, _prev, _prev + 2)); \
return 1; \
} \
-(BOOL)_isDeallocating { \
if (_rc_ivar == -2) { \
return 1; \
} else if (_rc_ivar < -2) { \
__builtin_trap(); /* BUG: over-release elsewhere */ \
} \
return _rc_ivar & 1; \
}
#define _OBJC_SUPPORTED_INLINE_REFCNT_LOGIC(_rc_ivar, _dealloc2main) \
_OBJC_SUPPORTED_INLINE_REFCNT_LOGIC_BLOCK(_rc_ivar, (^(id _self_ __attribute__((unused))) { \
if (_dealloc2main && !pthread_main_np()) { \
return _OBJC_DEALLOC_OBJECT_LATER; \
} else { \
return _OBJC_DEALLOC_OBJECT_NOW; \
} \
}))
#define _OBJC_SUPPORTED_INLINE_REFCNT(_rc_ivar) _OBJC_SUPPORTED_INLINE_REFCNT_LOGIC(_rc_ivar, 0)
#define _OBJC_SUPPORTED_INLINE_REFCNT_WITH_DEALLOC2MAIN(_rc_ivar) _OBJC_SUPPORTED_INLINE_REFCNT_LOGIC(_rc_ivar, 1)
同理，我們可以把這個宏拷貝出來，實現一個我們自己的類，做到類一定會在主線程釋放。有興趣的同學可以試試。
5 小結
本文分析了 iOS 中 UI 對象是如何實現保證在主線程釋放的現象和原理。
具體蘋果是從哪個系統版本還是這樣支持的，我還沒有去研究。
從蘋果的角度來看，既然要求了 UI 對象只能主線程訪問，但是 Block 捕獲 UI 對象的代碼真是太容易寫出來了，如果有辦法讓 UI 對象只能在主線程釋放，那么對于整體穩定性的收益絕對是巨大的。
