在这个篇章我们分析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()
! 这里也解释了:一旦我们的序列发出完成或者错误就无法再次响应了!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度仰望天空,该死!我这无处安放的魅力!