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 的观察和序列以及销毁者就是普通对象，ARC 申请开辟内存，开发人员正常处理就OK

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

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