RxSwift 销毁者核心销毁流程

RxSwift 销毁者核心销毁流程

在RxSwift中的代码中经常需要用disposeBag来做序列的销毁操作，那这背后的原理是怎么样工作的呢？我们根据源码来看看背后的原理。

var disposeBag = DisposeBag()

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("销毁回调")
}

// 依靠disposeBag销毁
dispose.disposed(by: disposeBag)
// 主动销毁
dispose.dispose()

整个销毁者的创建销毁流程图

高清无码Xmind下载地址

源码分析：
1、首先创建序列的时候，Disposables.create创建了一个闭包，返回AnonymousDisposable销毁者

public static func create(with dispose: @escaping () -> Void) -> Cancelable {
    return AnonymousDisposable(disposeAction: dispose)
}

2、AnonymousDisposable中init方法保存了外界的闭包self._disposeAction = disposeAction
3、在ObservableType.subscribe订阅序列的时候又返回了一个BinaryDisposable的销毁者

public func subscribe(onNext: ((Element) -> Void)? = nil, onError: ((Swift.Error) -> Void)? = nil, onCompleted: (() -> Void)? = nil, onDisposed: (() -> Void)? = nil) -> Disposable {
    let disposable: Disposable  
    if let disposed = onDisposed {
        disposable = Disposables.create(with: disposed)
    } else {
        disposable = Disposables.create()
    }
    // 省略
    return Disposables.create(
        self.asObservable().subscribe(observer),
        disposable
    )
}

public static func create(_ disposable1: Disposable, _ disposable2: Disposable) -> Cancelable {
    return BinaryDisposable(disposable1, disposable2)
}

4、在BinaryDisposable的初始化方法中保存了两个销毁者，self._disposable1 = self.asObservable().subscribe(observer)， self._disposable2 = AnonymousDisposable

init(_ disposable1: Disposable, _ disposable2: Disposable) {
    self._disposable1 = disposable1
    self._disposable2 = disposable2
    super.init()
}

5、那self._disposable1到底是什么呢？self.asObservable().subscribe(observer)由核心订阅逻辑知道这步肯定会走到Producer.subscribe()方法，由源码可知self._disposable1 = SinkDisposer

let disposer = SinkDisposer()
let sinkAndSubscription = self.run(observer, cancel: disposer)
disposer.setSinkAndSubscription(sink: sinkAndSubscription.sink, subscription: sinkAndSubscription.subscription)
return disposer

6、在Producer.subscribe()方法中调用了子类的run()方法和SinkDisposer.setSinkAndSubscription()方法，实际上就是保存了sink和subscription

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

7、那sink和subscription代表什么呢？再看源码可以知道sink = AnonymousObservableSink，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)
}

func run(_ parent: Parent) -> Disposable {
    return parent._subscribeHandler(AnyObserver(self))
}

8、依靠disposeBag销毁，首先创建了一个DisposeBag的实例来保存所有的销毁者，在这个实例销毁的时候再便利所有的销毁者进行销毁。看源码分析。

dispose.disposed(by: disposeBag)

public func disposed(by bag: DisposeBag) {
    bag.insert(self)
}

public final class DisposeBag: DisposeBase { 
    fileprivate var _disposables = [Disposable]()
    
    deinit {
        self.dispose()
    }
    public func insert(_ disposable: Disposable) {
        self._insert(disposable)?.dispose()
    }
    
    private func _insert(_ disposable: Disposable) -> Disposable? {
        self._lock.lock(); defer { self._lock.unlock() }
        if self._isDisposed {
            return disposable
        }
        self._disposables.append(disposable)
        return nil
    }
    
    private func dispose() {
        let oldDisposables = self._dispose()
        for disposable in oldDisposables {
            disposable.dispose()
        }
    }
    private func _dispose() -> [Disposable] {
        self._lock.lock(); defer { self._lock.unlock() }
        let disposables = self._disposables
        self._disposables.removeAll(keepingCapacity: false)
        self._isDisposed = true
        return disposables
    }
}

当disposeBag对象销毁的时候就会调用deinit方法，然后遍历存储在_disposables中的销毁者进行销毁操作。

9、主动调用dispose()方法进行销毁。

dispose.dispose()
相当于是调用BinaryDisposable.dispose()
func dispose() {
    if fetchOr(self._isDisposed, 1) == 0 {
        self._disposable1?.dispose()
        self._disposable2?.dispose()
        self._disposable1 = nil
        self._disposable2 = nil
    }
}

由之前的分析可知self._disposable1 = SinkDisposer，self._disposable2 = AnonymousDisposable，分别调用dispose()方法销毁

fileprivate final class SinkDisposer: Cancelable {
    func dispose() {
        sink.dispose()
        subscription.dispose()
        self._sink = nil
        self._subscription = nil
    }
}

以上就是整个销毁者的创建到销毁的流程了，销毁的过程并不是销毁了对象，而是销毁的是订阅者、序列之间的关系连接。