RxSwift（11）— dispose源码解析

就问此时此刻还有谁？45度仰望天空，该死！我这无处安放的魅力！

• RxSwift（1）— 初探
• RxSwift（2）— 核心逻辑源码分析
• RxSwift（3）— Observable序列的建立方式
• RxSwift（4）— 高阶函数（上）
• RxSwift（5）— 高阶函数（下）
• RxSwift（6）— 调度者-scheduler源码解析（上）
• RxSwift（7）— 调度者-scheduler源码解析（下）
• RxSwift（8）— KVO底层探索（上）
• RxSwift（9）— KVO底层探索（下）
• RxSwift（10）— 场景序列总结
• RxSwift（11）— dispose源码解析
• RxSwift（12）— Subject即攻也守
• RxSwift（13）— 爬过的坑
• RxSwift（14）— MVVM双向绑定

---

RxSwift 目录直通车 --- 和谐学习，不急不躁！

---

在这个篇章咱们分析RxSwift一个很是重要的元素 一 销毁者！这一元素也是咱们 Rxswift 四俊杰之一。销毁者在Rxswift的世界里面扮演的角色也是很是重要的，因此对它的深刻解析，才能帮助咱们对Rxswift更好的理解

销毁者初探

首先给你们看一段代码，咱们从基本序列建立和订阅开始分析

// 建立序列
let ob = Observable<Any>.create { (observer) -> Disposable in
    observer.onNext("Cooci")
    return Disposables.create {
            print("销毁释放了")
        }
}
// 序列订阅
let dispose = ob.subscribe(onNext: { (anything) in
    print("订阅到了:\(anything)")
}, onError: { (error) in
    print("订阅到了:\(error)")
}, onCompleted: {
    print("完成了")
}) {
    print("销毁回调")
}
复制代码

• 这段代码里面关于销毁者相关的就是咱们建立序列的回调闭包 Disposables.create {print("销毁释放了")} 按照前面我给你们分享的代码技巧，这里就不会迷路！能够直接定位到核心代码

extension Disposables {
    public static func create(with dispose:) -> Cancelable {
        return AnonymousDisposable(disposeAction: dispose)
    }
}
复制代码

• 建立了一个匿名销毁者 AnonymousDisposable 跟咱们的序列，订阅者同样的手法，不一样的业务逻辑必然还有其余细节操做，可是咱们从通常入手快速直接

fileprivate init(disposeAction: @escaping DisposeAction) {
    self._disposeAction = disposeAction
    super.init()
}

// 核心逻辑
fileprivate func dispose() {
    if fetchOr(self._isDisposed, 1) == 0 {
        if let action = self._disposeAction {
            self._disposeAction = nil
            action()
        }
    }
}
复制代码

• 上面咱们能够看到初始化就是保存了响应回调闭包，那么在何时回调呢？就在下面咱们标记的核心逻辑代码 - dispose()
• fetchOr(self._isDisposed, 1) 是一个单项标记手段，咱们通常操做就是属性标记，这里利用的是更装逼的算法标记：下降依赖和更加快速
• 上面方法的意思就是保证只会销毁一次
• 下面就是对回调闭包取出而后置空销毁 self._disposeAction = nil
• 对取出的闭包调用执行： action()

如今感受一切很顺利，可是聪明的咱们必定要知道这里落下一个重要的前导因素：何时调用了 dispose()

销毁调用

上面的流程，咱们是在序列的回调闭包：subscriberHandle里面，其实这个流程以前还有一个很是重要的流程：订阅 subscriber

if let disposed = onDisposed {
  disposable = Disposables.create(with: disposed)  
}else {
  disposable = Disposables.create()
 }
复制代码

• 这里就是保存外界销毁闭包的保存 - 达到提示销毁

switch event {
case .next(let value):
    onNext?(value)
case .error(let error):
  // 响应外界调回闭包
    disposable.dispose()
case .completed:
  // 响应外界调回闭包
    disposable.dispose()
}
复制代码

• 观察者回调里面调用， 响应外界调回闭包
• return Disposables.create(self.asObservable().subscribe(observer),disposable) 综合来看，咱们的重点必然在这句代码，沟通下面流程的 subscribe, 外界订阅返回的销毁者（能够随时随地进行 dispose.dispose() ）
• 上面代码跟进去看到BinaryDisposable(disposable1, disposable2) 原来建立的二元销毁者！

func dispose() {
    if fetchOr(self._isDisposed, 1) == 0 {
        self._disposable1?.dispose()
        self._disposable2?.dispose()
        self._disposable1 = nil
        self._disposable2 = nil
    }
}
复制代码

• 二元销毁者的 dispose 方法也在预料之中，分别销毁
• 那么咱们的重点就应该探索，在 subscribe 这里面建立的关键销毁者是什么?
• 下面咱们进入很是熟悉的：Producer

let disposer = SinkDisposer()
let sinkAndSubscription = self.run(observer, cancel: disposer)
disposer.setSinkAndSubscription(sink: sinkAndSubscription.sink,
 subscription: sinkAndSubscription.subscription)
// 返回销毁者
return disposer
复制代码

• 看到 SinkDisposer 我内心舒服了！一切都是那么熟悉，普通销毁者：AnonymousDisposable , 关键销毁者： SinkDisposer
• 首先咱们不着急具体去查阅 SinkDisposer 里面实现
• 先看什么东西进入了 SinkDisposer
• self.run(observer, cancel: disposer) 证实里面须要用到 SinkDisposer
• disposer.setSinkAndSubscription 常规操做，也看看源码把

func setSinkAndSubscription(sink: Disposable, subscription: Disposable) {
    self._sink = sink
    self._subscription = subscription

// 获取状态 
    let previousState = fetchOr(self._state, 
DisposeState.sinkAndSubscriptionSet.rawValue)

// 若是状态知足就销毁
    if (previousState & DisposeState.disposed.rawValue) != 0 {
        sink.dispose()
        subscription.dispose()
        self._sink = nil
        self._subscription = nil
    }
}
复制代码

• 保存了两个属性 : sink 和 subscription(就是外界建立序列的闭包的返回销毁者)
• 取了某一个状态：previousState,判断状态的条件，而后执行 这两个保存属性的销毁和置空释放销毁 ： .dispose() + = nil
• 实际上是能够理解，就是咱们在加入的东西其实须要销毁的，不该该保留的，那么不必给它继续保留生命迹象

OK 剩下咱们还去一个传进去的销毁者，去干嘛？咱们也跟一下源码！

// 建立 sink 保存了销毁者
let sink = AnonymousObservableSink(observer: observer, cancel: cancel)

// 中间流程省略。。。。

func on(_ event: Event<Element>) {
    switch event {
    case .next:
        self.forwardOn(event)
    case .error, .completed:
        if fetchOr(self._isStopped, 1) == 0 {
            self.forwardOn(event)
            // 关键点：完成和错误信号的响应式必然会直接开启销毁的
            self.dispose()
        }
    }
}
复制代码

• 完成和错误信号的响应式必然会直接开启销毁的 ： self.dispose()! 这里也解释了：一旦咱们的序列发出完成或者错误就没法再次响应了！
• 剩下一个BIG问题： 到底咱们的销毁的是什么

func dispose() {
    let previousState = fetchOr(self._state, DisposeState.disposed.rawValue)

    if (previousState & DisposeState.sinkAndSubscriptionSet.rawValue) != 0 {
        sink.dispose()
        subscription.dispose()

        self._sink = nil
        self._subscription = nil
    }
}
复制代码

• 不管咱们直接销毁仍是系统帮助咱们销毁必然会调用：dispose()
• 咱们查看 dispose() 得出: 就是在初始化初期咱们保留的两个属性的操做
• sink.dispose() + self._sink = nil & subscription.dispose() + self._subscription = nil 执行相关释放和销毁
• 若是你细细品来你会慢慢感知到：这种设计是对的！
• 咱们在 RxSwift 的世界里最重要的东西，咱们就是经过：序列，观察者 来创建响应关系！若是咱们断开了响应关系不就达到销毁的目标？然而咱们断开响应关系最重要的就是：Sink
• 不少同窗可能会问：那么咱们建立的序列、观察者对象怎么办？你无论了？
• 第一：内部建立的临时序列和观察者都会随着对外的观察者和序列的生命周期而销毁释放。
• 第二：外界观察者和序列会随着他们的做用域空间而释放
• 第三：释放不了只是对象的释放有问题，常规内存管理问题
• 第四：最为一个再牛逼的框架也不能对程序员写的代码直接管理控制
• 第五：RxSwift 的观察和序列以及销毁者就是普通对象，最为开发人员正常处理就OK

RxSwift 的销毁者的设计我的感受仍是比较精妙的，对于整个框架的连贯和总体性再次验证！但愿读者读者用心感觉设计思路！

完美！解析到这里，整个流程解析完毕

就问此时此刻还有谁？45度仰望天空，该死！我这无处安放的魅力！