RxSwift源码分析(六)-销毁者Disposable

时间  2019-11-08
标签 rxswift 源码 分析 销毁 disposable 繁體版
原文   原文链接

销毁者简介

可被清除的资源Disposable是RxSwift的核心成员之一，它主要是用来清除再也不须要的资源。那么下面来探索一下RxSwift是怎样管理这些资源的生命周期呢。 api

  • 一般来讲，一个序列若是发出了 error 或者 completed 事件，那么全部内部资源都会被释放，不须要咱们手动释放。
  • 可是若是你须要提早释放这些资源或取消订阅的话，那么你能够对返回的可被清除的资源（Disposable） 调用 dispose 方法。
  • 不过官方推荐使用清除包（DisposeBag）来管理订阅的生命周期，通常是把资源加入到一个全局的DisposeBag里面，它跟随着页面的生命周期，当页面销毁时DisposeBag也会随之销毁，同时DisposeBag里面的资源也会被一一释放。
var disposeBag = DisposeBag() // 来自父类 ViewController

override func viewDidLoad() {
    super.viewDidLoad()

    ...

    usernameValid
        .bind(to: passwordOutlet.rx.isEnabled)
        .disposed(by: disposeBag)

    usernameValid
        .bind(to: usernameValidOutlet.rx.isHidden)
        .disposed(by: disposeBag)
}
复制代码

销毁者的实现探索

下面这一段代码是常规的建立一个序列，而后订阅，最后手动销毁的流程。安全

let observable = Observable<Any>.create { (observer) -> Disposable in
    observer.onNext("七夕快乐")
    return Disposables.create {
        print("销毁释放了")
    }
}

let dispose = observable.subscribe(onNext: { (message) in
    print("有一条新消息:\(message)")
}, onError: { (error) in
    print("错误")
}, onCompleted: {
    print("完成")
}) {
    print("销毁回调")
}

print("开始调用dispose")
dispose.dispose()
复制代码
执行结果：
有一条新消息:七夕快乐
开始调用dispose
销毁释放了
销毁回调
复制代码
  • 首先能够看到，在建立序列Observable<Any>.create方法有一个尾随闭包，须要返回一个实现了Disposable协议的实例。
  • 进入到Disposables.create方法里面看看
extension Disposables {
    public static func create(with dispose: @escaping () -> Void) -> Cancelable {
        return AnonymousDisposable(disposeAction: dispose)
    }
}
复制代码
  • 建立了一个AnonymousDisposable对象并返回，很明显，这是一个匿名销毁者，跟建立序列的时候会建立一个匿名序列实现方式很是类似。
fileprivate final class AnonymousDisposable : DisposeBase, Cancelable {
    public typealias DisposeAction = () -> Void

    private let _isDisposed = AtomicInt(0)
    private var _disposeAction: DisposeAction?

    public var isDisposed: Bool {
        return isFlagSet(self._isDisposed, 1)
    }

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

    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) == 0这行代码是控制if语句里面只会进去一次。
  • fetchOr方法的具体实现：AtomicInt是继承NSLock，在更改value值的时候加了一把锁，保证线程安全，而后运用了或运算并保存结果。位运算更加的高效。
  • 最后先把self._disposeAction赋值给临时变量action，而后置空self._disposeAction，再执行action()。这样操做的缘由是若是_disposeAction闭包是一个耗时操做，也可以保证_disposeAction可以当即释放。
func fetchOr(_ this: AtomicInt, _ mask: Int32) -> Int32 {
    this.lock()
    let oldValue = this.value
    this.value |= mask
    this.unlock()
    return oldValue
}
复制代码
final class AtomicInt: NSLock {
    fileprivate var value: Int32
    public init(_ value: Int32 = 0) {
        self.value = value
    }
}
复制代码
  • 上面的流程，咱们是在序列的回调闭包：_subscriberHandle里面，其实这个流程以前还有一个很是重要的流程：订阅，进入到observable.subscribe方法
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()
    }
    
    let observer = AnonymousObserver<Element> { event in
        switch event {
        case .next(let value):
            onNext?(value)
        case .error(let error):
            if let onError = onError {
                onError(error)
            }
            else {
                Hooks.defaultErrorHandler(callStack, error)
            }
            disposable.dispose()
        case .completed:
            onCompleted?()
            disposable.dispose()
        }
    }
    
    return Disposables.create(
        self.asObservable().subscribe(observer),
        disposable
    )
}
复制代码
  • 首先建立了一个Disposable对象，并保存了销毁回调闭包，当执行销毁时，会把消息回调出去
  • 在发出错误和完成事件以后也会执行disposable.dispose()，这就证明了前面说的：一个序列若是发出了 error 或者 completed 事件，那么全部内部资源都会被释放，不须要咱们手动释放。
  • 看最后一行代码return Disposables.create( self.asObservable().subscribe(observer), disposable )，这里返回的Disposable对象就是咱们外面手动调用dispose.dispose()方法的dispose对象，或者说是加入到全局的DisposeBag的销毁者。
  • 跟踪进入查看代码
public static func create(_ disposable1: Disposable, _ disposable2: Disposable) -> Cancelable {
    return BinaryDisposable(disposable1, disposable2)
}
复制代码
  • 建立了一个二元销毁者
func dispose() {
    if fetchOr(self._isDisposed, 1) == 0 {
        self._disposable1?.dispose()
        self._disposable2?.dispose()
        self._disposable1 = nil
        self._disposable2 = nil
    }
}
复制代码
  • 当执行dispose()时会把2个销毁者分别销毁
  • 而后再来看看这个二元销毁者建立时的第一个参数：self.asObservable().subscribe(observer)的返回值是什么。来到Producer类的subscribe方法
let disposer = SinkDisposer()
let sinkAndSubscription = self.run(observer, cancel: disposer)
disposer.setSinkAndSubscription(sink: sinkAndSubscription.sink, subscription: sinkAndSubscription.subscription)
return disposer
复制代码
  • 建立了一个sink的销毁者SinkDisposer对象并返回，因此前面建立二元销毁者的第二个参数就是它。通过以前对RxSwift核心逻辑的分析文章，咱们知道sink是链接序列和观察者的桥梁，当sink销毁后，序列和观察者之间就没法通信了。
  • 进入到self.run(observer, cancel: disposer)
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)
}
复制代码
  • 建立了一个AnonymousObservableSink对象，并保存了上一步建立的SinkDisposer对象。在AnonymousObservableSink的源码里面发现on方法中，当发出完成和错误信号后，会当即执行dispose进行销毁，因此一旦咱们的序列发出完成或者错误信号后就没法再次响应了！
  • 执行sink.run(self)，方法里面执行的是parent._subscribeHandler(AnyObserver(self))，_subscribeHandler闭包就是外面建立序列Observable<Any>.create的尾随闭包，因此返回值就是Disposables.create {print("销毁释放了")}。
  • 进入到setSinkAndSubscription方法
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
    }
}
复制代码
  • 保存了两个属性 : sink 和 subscription，就是上一步返回的销毁者和AnonymousObservableSink对象，AnonymousObservableSink里面保存了sink的销毁者SinkDisposer
  • 根据记录的一个状态去判断刚刚保存的这两个属性是否须要销毁，须要的话就执行 dispose() 而后置空 nil
  • 那么，当执行dispose.dispose()销毁时销毁的究竟是什么呢
func dispose() {
    let previousState = fetchOr(self._state, DisposeState.disposed.rawValue)

    if (previousState & DisposeState.disposed.rawValue) != 0 {
        return
    }
    if (previousState & DisposeState.sinkAndSubscriptionSet.rawValue) != 0 {

        sink.dispose()
        subscription.dispose()

        self._sink = nil
        self._subscription = nil
    }
}
复制代码
  • 无论是系统销毁仍是咱们手动销毁都会执行dispose(),咱们查看 dispose() 得出: 就是把初始化的时候保存的两个属性进行销毁而后置空。
  • 在RxSwift中，sink存放了序列和观察者，来创建它们之间的响应关系，当把序列和观察者之间的桥梁sink销毁了，也就断开了它们之间的响应关系，从而没法再接收到消息。
  • 附上一张图

总结

  • 一个序列若是发出了 error 或者 completed 事件，那么全部内部资源都会被释放，不须要咱们手动释放。
  • 当执行销毁时，销毁的是序列和观察者之间的响应关系，不是序列和观察者对象自己
  • 若是是加入到disposeBag，是在disposeBag对象销毁时，依次销毁里面存储的东西
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程