前言
关于RxSwift还有一个非常重要的角色一直没有探索，那就是RxSwift里负责清除垃圾的销毁者。这篇文章将探索RxSwift的源码解析。
提出问题
以下是一段基本序列的创建和订阅代码:
// 创建序列
let ob = Observable<Any>.create { (observer) -> Disposable in
observer.onNext("1111")
return Disposables.create { print("销毁释放了")} // dispose.dispose()
}
// 序列订阅
let dispose = ob.subscribe(onNext: { (anything) in
print("订阅到了:\(anything)")
}, onError: { (error) in
print("订阅到了:\(error)")
}, onCompleted: {
print("完成了")
}) {
print("销毁回调")
}
print("执行完毕")
//销毁序列
dispose.dispose()
我们试着运行一下这段代码，然后发现打印顺序如下所示:
订阅到了:1111
执行完毕
销毁释放了
销毁回调
可以发现在调用dispose.dispose()后，先执行的是这个创建序列的回调闭包Disposables.create { print("销毁释放了")},再执行的{print("销毁回调")}，来探索一下这里面的几个问题吧，带着问题去找答案:
- 为什么调用
dispose()方法能够执行创建序列时的闭包呢? - 为什么是先执行创建序列的闭包，再执行后面的销毁回调闭包呢？
-
dispose()方法到底是如何实现销毁序列的呢？销毁的是什么？
销毁者创建
- 点进
Disposables.create，发现这里返回了一个匿名销毁者AnonymousDisposable
public static func create(with dispose: @escaping () -> Void) -> Cancelable {
return AnonymousDisposable(disposeAction: dispose)
}
- 再进去看看，发现在
AnonymousDisposable里把这个闭包保存在自己的_disposeAction里了
fileprivate init(_ disposeAction: @escaping DisposeAction) {
self._disposeAction = disposeAction
super.init()
}
- 然而什么时候调用呢？发现就在下面的
dispose()方法里面，
// 核心逻辑
fileprivate func dispose() {
if fetchOr(self._isDisposed, 1) == 0 {
if let action = self._disposeAction {
self._disposeAction = nil
action()
}
}
}
- 这里有个重要的方法，
fetchOr(self._isDisposed, 1)，它是一个单项标记手段，点进去看看, 我后面加了注释。this.value初值是0, 所以返回的oldValue也是0。 - 我们传的
mask是1,this.value |= mask按位或运算，this.value值变为了1。 - 所以 只有第一次调用
fetchOr, 返回的是0 , 第二次以后，再调用fetchOr，返回的都是1，各位自行理解一下
func fetchOr(_ this: AtomicInt, _ mask: Int32) -> Int32 {
this.lock()
let oldValue = this.value // 0 1
this.value |= mask // 1 1
this.unlock()
return oldValue // 0 1
}
我们再看这个代码，意思就是销毁的代码只执行一次，所以当前_disposeAction置为nil后再执行尾随必包action，只是还不知道这个dispose什么时候调用
// 核心逻辑
fileprivate func dispose() {
if fetchOr(self._isDisposed, 1) == 0 {
if let action = self._disposeAction {
self._disposeAction = nil
action()
}
}
}
销毁dispose()方法调用
- 回到外界点
subsricbe进入订阅方法内容查看，发现在这里保存了外界这个销毁提示的闭包
if let disposed = onDisposed {
disposable = Disposables.create(with: disposed)
}else {
disposable = Disposables.create()
}
- 我们再看到创建
observer里的event，我们看到在.error和.completed里，都调用了这个dispose方法，也就是我们上面AnonymousDisposable里的dispose方法。这符合我们的猜想，在完成或者报错后，要销毁这个订阅关系。
switch event {
case .next(let value):
onNext?(value)
case .error(let error):
if let onError = onError {
onError(error)
}
disposable.dispose()
case .completed:
onCompleted?()
disposable.dispose()
}
}
- 那么
.next事件是如何调用dispose的呢？看到下面，这里貌似创建了一个销毁者Disposables，点进去看看
return Disposables.create(
self.asObservable().subscribe(observer),
disposable
)
- 创建了一个
BinaryDisposable二元销毁者,把刚刚的两个要销毁的disposable都传进去了
/// Creates a disposable with the given disposables.
public static func create(_ disposable1: Disposable, _ disposable2: Disposable) -> Cancelable {
return BinaryDisposable(disposable1, disposable2)
}
点进BinaryDisposable,可以看到把传递进来的disposable1和disposable2都保存起来了
init(_ disposable1: Disposable, _ disposable2: Disposable) {
self._disposable1 = disposable1
self._disposable2 = disposable2
super.init()
}
我们看到也有一个dispose()方法，还是和之前探索到的一样，也是在这个方法里销毁。但是还没看到这里是什么时候调用的，先记住这个地方。
func dispose() {
if fetchOr(self._isDisposed, 1) == 0 {
self._disposable1?.dispose()
self._disposable2?.dispose()
self._disposable1 = nil
self._disposable2 = nil
}
}
- 再回到第3步，
self.asObservable().subscribe(observer)这里创建的销毁者到底是什么呢？
return Disposables.create(
self.asObservable().subscribe(observer),
disposable
)
- 我们这里直接找
Producer里的subscribe方法（为什么直接找Producer,后之前探索核心逻辑的时候，知道Producer里的subscribe是会先执行的）
看到SinkDisposer(),有种熟悉的感觉，先去看看self.run返回的是什么?
let disposer = SinkDisposer()
let sinkAndSubscription = self.run(observer, cancel: disposer)
disposer.setSinkAndSubscription(sink: sinkAndSubscription.sink, subscription: sinkAndSubscription.subscription)
我们发现这里返回的是AnonymousObservableSink和subscription 一个元组类型, subscription是一个AnonymousDisposable
override func run<Observer: ObserverType>(_ observer: Observer, cancel: Cancelable) -> (sink: Disposable, subscription: Disposable) where Observer.Element == Element {
let sink = AnonymousObservableSink(observer: observer, cancel: cancel)
let subscription = sink.run(self)
return (sink: sink, subscription: subscription)
}
可能会不理解为什么是AnonymousDisposable，因为我们点sink.run过去发现就是调用的这里保存的_subscribeHandler,而这个_subscribeHandler是由我们外界传递过来的闭包,就是create后面跟随的闭包
// 创建序列
let ob = Observable<Any>.create { (observer) -> Disposable in
observer.onNext("1111")
return Disposables.create { print("销毁释放了")} // dispose.dispose()
}
- 回到这里,我们已经知道了
sinkAndSubscription这个元组的内容了，继续探索disposer.setSinkAndSubscription干了什么
let disposer = SinkDisposer()
let sinkAndSubscription = self.run(observer, cancel: disposer)
disposer.setSinkAndSubscription(sink: sinkAndSubscription.sink, subscription: sinkAndSubscription.subscription)
- 这里把
sink和subscription都保存起来了，还可以看到有一个previousState的状态，如果状态满足的话，就会调用销毁方法，把这两个都销毁
其实是可以理解为，就是我们在加入的东西其实需要销毁的，不应该保留的，那么没必要给它继续保留生命迹象
func setSinkAndSubscription(sink: Disposable, subscription: Disposable) {
self._sink = sink
self._subscription = subscription
// 获取状态
let previousState = fetchOr(self._state, DisposeState.sinkAndSubscriptionSet.rawValue)
if (previousState & DisposeState.sinkAndSubscriptionSet.rawValue) != 0 {
rxFatalError("Sink and subscription were already set")
}
// 如果状态满足就销毁
if (previousState & DisposeState.disposed.rawValue) != 0 {
sink.dispose()
subscription.dispose()
self._sink = nil
self._subscription = nil
}
}
最后，在外界调用dispose.dispose()的时候，点进去看，这里便会层层销毁，流程里实现的dispose()方法都会调用，sink,subscription也都会销毁。
总结
我们在RxSwift整个核心流程里，最重要的是什么？就是sink,通过这个管道把我们整个订阅响应的流程串起来了，所以销毁者最重要的就是要销毁这个管道！整个框架设计的无比精妙，确实颇有收获，希望大家也能认真研究一下！
