今天捋了一下RXSwift中的销毁者，想到之前的观察者，突然来了灵魂一问：
观察者和销毁者的本质是什么？
刚开始想到这个问题是，自己也懵逼了，是啥子？我的天我也不晓得，突然感觉近一个月的RX白学了，真的好惭愧。
还是先讲讲销毁者的底层原理实现吧，问题的答案放在最后面。先来一个最基本的rx实例：
// 创建序列
let ob = Observable<Any>.create { (observer) -> Disposable in
observer.onNext("Cooci")
return Disposables.create { print("销毁释放了")} // dispose.dispose()
}
// 序列订阅
let dispose = ob.subscribe(onNext: { (anything) in
print("订阅到了:\(anything)")
}, onError: { (error) in
print("订阅到了:\(error)")
}, onCompleted: {
print("完成了")
}) {
print("销毁回调")
}
dispose.dispose()
Disposables.create { print("销毁释放了")} 返回 -> Disposable，这里创建了一个 销毁者1️⃣
extension Disposables {
/// Constructs a new disposable with the given action used for disposal.
///
/// - parameter dispose: Disposal action which will be run upon calling `dispose`.
public static func create(with dispose: @escaping () -> Void) -> Cancelable {
return AnonymousDisposable(disposeAction: dispose)
}
}
创建一个销毁者1️⃣时，初始化保存闭包1️⃣{ print("销毁释放了”))，这个销毁者最后会被sinkDispose拿到，后面会讲
fileprivate init(_ disposeAction: @escaping DisposeAction) {
self._disposeAction = disposeAction
super.init()
}
AnonymousDisposable继承了DisposeBase，实现了协议Cancelable，Disposable里面的最重要的一个方法func dispose()，实现方法如下，后面会用到。fileprivates 是一个私有方法，说明最后需要自己去管理自己的生命周期，因为别人不能调用这个方法0.0
fileprivate func dispose() {
if fetchOr(self._isDisposed, 1) == 0 {
if let action = self._disposeAction {
self._disposeAction = nil
action()
}
}
}
fetchOr(self._isDisposed, 1) == 0为单向标记，说白了就是一个true/false的记号，判断是否销毁过而已
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 1 1 1 1 1 1
}
拿到一个值，和1进行或运算，oldValue默认为0，也就是第一次一定返回0，0==0，为true
第二次时，我们首先要清楚oldValue == this.value ==1了，1和任何数或运算都是1，1==0，为false，且后面永远为false 了，很完美的设计。
dispose里面，把之前保存的闭包设置为nil，然后调用临时常量函数执行闭包的内容。fetchOr的原因这个闭包只能被调用一次（为什么是先nil在调用，因为闭包中可能是一个耗时的操作）,这种方法来使程序执行一次，是很值得大家去学习的方法，老骚了。
闭包1️⃣到底是在什么时候调用的呢？后面会提到，先看看订阅干了什么：
public func subscribe(onNext: ((Element) -> Void)? = nil, onError: ((Swift.Error) -> Void)? = nil, onCompleted: (() -> Void)? = nil, onDisposed: (() -> Void)? = nil)
-> Disposable {
//*************************创建了一个disposable销毁者 保存闭包2️⃣{print("销毁回调")}****************************
let disposable: Disposable
if let disposed = onDisposed {
disposable = Disposables.create(with: disposed)
}
else {
disposable = Disposables.create()
}
*****************************************************//
#if DEBUG
let synchronizationTracker = SynchronizationTracker()
#endif
let callStack = Hooks.recordCallStackOnError ? Hooks.customCaptureSubscriptionCallstack() : []
let observer = AnonymousObserver<Element> { … }
return Disposables.create(
self.asObservable().subscribe(observer),
disposable
)
}
}
return Disposables.create( self.asObservable().subscribe(observer),disposable )这个是一个二元销毁者：
extension Disposables {
/// Creates a disposable with the given disposables.
public static func create(_ disposable1: Disposable, _ disposable2: Disposable) -> Cancelable {
return BinaryDisposable(disposable1, disposable2)
}
}
disposable1 是调用ob的produce的subscribe返回的销毁者SinkDisposer,
disposable2 销毁者
订阅时创建 销毁者2️⃣，保存闭包2️⃣
private final class BinaryDisposable : DisposeBase, Cancelable {
...
func dispose() {
if fetchOr(self._isDisposed, 1) == 0 {
self._disposable1?.dispose()
self._disposable2?.dispose()
self._disposable1 = nil
self._disposable2 = nil
}
}
}
func dispose()这个dispose是可以对外的。然后我们在最外面调用了dispose.dispose()，完成了销毁的操作，其实到这里就已经完成了销毁,任务完成了。然而我们到底销毁了什么鬼东西呢？，_disposable1和_disposable2是什么鬼东西？.dispose()里面干什么了？下面进行探究.
我们去查看self.asObservable().subscribe(observer),这句代码
class Producer<Element> : Observable<Element> {
。。。
override func subscribe<Observer: ObserverType>(_ observer: Observer) -> Disposable where Observer.Element == Element {
if !CurrentThreadScheduler.isScheduleRequired {
// The returned disposable needs to release all references once it was disposed.
let disposer = SinkDisposer()
let sinkAndSubscription = self.run(observer, cancel: disposer)
disposer.setSinkAndSubscription(sink: sinkAndSubscription.sink, subscription: sinkAndSubscription.subscription)
return disposer
}
else {
return CurrentThreadScheduler.instance.schedule(()) { _ in
//可以直接看这里，进行了disposer，然后调用setSinkAndSubscription，最后返回disposer销毁者
let disposer = SinkDisposer()
let sinkAndSubscription = self.run(observer, cancel: disposer)
disposer.setSinkAndSubscription(sink: sinkAndSubscription.sink, subscription: sinkAndSubscription.subscription)
return disposer
}
}
}
。。。
}
//***************************************************************
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
}
}
//***************************************************************
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)
}
最后销毁的就是 (sink: sink, subscription: subscription)这两个东西了：
sink ——就是沟通序列和观察者的sink
let subscription = sink.run(self)
//******************
func run(_ parent: Parent) -> Disposable {
return parent._subscribeHandler(AnyObserver(self))
}
也就是 subscription 是create闭包里面的返回值，销毁者1️⃣。
最后外层的dispose.dispose()调用，干掉sink，销毁者1️⃣，然后是订阅内的销毁者2️⃣，所以我们销毁时，会先执行create内的销毁者闭包，然后才是订阅内的销毁者闭包,具体代码如下：
二元销毁者销毁的内容如下：
第一个是disposer = SinkDisposer()
fileprivate final class SinkDisposer: Cancelable {
func dispose() {
let previousState = fetchOr(self._state, DisposeState.disposed.rawValue)
if (previousState & DisposeState.disposed.rawValue) != 0 {
return
}
if (previousState & DisposeState.sinkAndSubscriptionSet.rawValue) != 0 {
guard let sink = self._sink else {
rxFatalError("Sink not set")
}
guard let subscription = self._subscription else {
rxFatalError("Subscription not set")
}
sink.dispose()
subscription.dispose()
self._sink = nil
self._subscription = nil
}
}
}
第二个参数是销毁者2️⃣，dispose方法
disposable = Disposables.create(with: disposed)
//*************************************************
public static func create(with dispose: @escaping () -> Void) -> Cancelable {
return AnonymousDisposable(disposeAction: dispose)
}
//*************************************************
fileprivate final class AnonymousDisposable : DisposeBase, Cancelable {
fileprivate func dispose() {
if fetchOr(self._isDisposed, 1) == 0 {
if let action = self._disposeAction {
self._disposeAction = nil
action()
}
}
}
}
答案：其实销毁者观察者本质是协议，而序列的本质其实是class类，很简单的问题~~~只是别名叫多了忘记了本质了。
