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 对象只能在主线程释放，那么对于整体稳定性的收益绝对是巨大的。