RxSwift是由
序列,观察者,调度者,销毁者组成。可见,销毁者在RxSwift的重要性。了解销毁者,才能更好的了解RxSwift。
销毁者
我们依然从最基础的序列创建和订阅入手:
// 创建序列
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("销毁回调")
}
与销毁者相关的代码只有Disposables.create { print("销毁释放了")}
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)
}
}
Disposables.create返回的是AnonymousDisposable对象
fileprivate final class AnonymousDisposable : DisposeBase, Cancelable {
public typealias DisposeAction = () -> Void
/// Constructs a new disposable with the given action used for disposal.
///
/// - parameter disposeAction: Disposal action which will be run upon calling `dispose`.
fileprivate init(_ disposeAction: @escaping DisposeAction) {
self._disposeAction = disposeAction
super.init()
}
}
对象初始化中,将外界传入的闭包保存在_disposeAction。类中包含dispose()方法，这就是销毁着调用的方法
fileprivate func dispose() {
if fetchOr(self._isDisposed, 1) == 0 {
if let action = self._disposeAction {
self._disposeAction = nil
action()
}
}
}
AnonymousDisposable中_isDisposed初始值为0,
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
}
fetchOr调用一次后_isDisposed就会改为1，其实就是属性标记,保证dispose()只执行一次。它这个标记方法中,没有直接操作业务属性,所以不会产生依赖。并且使用的是位运算，更加快速。
dispose()中,将_disposeAction保存到action,清除_disposeAction,执行 action()` 。
dispose()调用
上面的流程是在subscriberHandle回调闭包中,在subscriberHandle之还有一个重要的订阅流程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()
}
}
创建Disposables,并保存外界闭包disposed
结合上面的分析，我们知道return Disposables.create(self.asObservable().subscribe(observer),disposable)是我们分析的重点。
public static func create(_ disposable1: Disposable, _ disposable2: Disposable) -> Cancelable {
return BinaryDisposable(disposable1, disposable2)
}
这是一个二元销毁者,返回Disposables可以让外界随时随地的调用dispose()
private final class BinaryDisposable : DisposeBase, Cancelable {
private let _isDisposed = AtomicInt(0)
// state
private var _disposable1: Disposable?
private var _disposable2: Disposable?
/// - returns: Was resource disposed.
var isDisposed: Bool {
return isFlagSet(self._isDisposed, 1)
}
/// Constructs new binary disposable from two disposables.
///
/// - parameter disposable1: First disposable
/// - parameter disposable2: Second disposable
init(_ disposable1: Disposable, _ disposable2: Disposable) {
self._disposable1 = disposable1
self._disposable2 = disposable2
super.init()
}
func dispose() {
if fetchOr(self._isDisposed, 1) == 0 {
self._disposable1?.dispose()
self._disposable2?.dispose()
self._disposable1 = nil
self._disposable2 = nil
}
}
}
二元销毁者保存2个销毁者对象_disposable1,_disposable2
dispose()使用fetchOr保证销毁代码执行一次,分别调用2个销毁者的dispose()方法，并设置为Nil。
self.asObservable().subscribe(observer)方法的调用,我们知道订阅流程会来到Producer的subscribe(observer)
let disposer = SinkDisposer()
let sinkAndSubscription = self.run(observer, cancel: disposer)
disposer.setSinkAndSubscription(sink: sinkAndSubscription.sink, subscription: sinkAndSubscription.subscription)
return disposer
普通的销毁者是AnonymousDisposable，而这个地方用的是SinkDisposer
1.初始化SinkDisposer类型的disposer.
2.sinkAndSubscription是子类返回的元组(sink: sink, subscription: subscription),
sink 保存观察者observer,销毁者disposer.
subscription保存的是外界返回的销毁者
3.disposer.setSinkAndSubscription(sink: sinkAndSubscription.sink, subscription: sinkAndSubscription.subscription),disposer保存_sink和subscription
previousState状态判断对象是否已经销毁,如已销毁调用sink和_subscription的dispose()并设置为nil
SinkDisposer的func dispose()通过previousState状态保证只销毁一次,
sink和_subscription分别调用dispose()并设置为nil
dispose()方法在什么时候执行?
1.完成和错误信号的响应式必然会直接开启销毁
2.手动调用dispose.dispose()，
3.系统帮助我们销毁
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
}
deinit {
self.dispose()
}
系统帮我们销毁会在垃圾袋回收时,deinit中循环垃圾袋中的所有对象，并分别调用dispose()
销毁的本质
通过分析,我们知道RxSwift的销毁者实际上销毁的是响应式关系。RxSwift通过序列和观察者来建立响应关系！如果我们断开了响应关系就已达到销毁的目标。
关于对象的回收，外界观察者和序列会随着他们的作用域空间而释放，内部创建的临时序列和观察者都会随着对外的观察者和序列的生命周期而销毁释放。
总结
1.Disposables.create(self.asObservable().subscribe(observer),disposable)调用订阅时创建的Disposables的dispose(),然后对二元销毁者分别调用dispose()并设置为nil
-
disposable保存的是订阅时,传入的闭包,disposable.dispose()销毁RxSwift与外界的关联。self.asObservable().subscribe(observer)是SinkDisposer,因此调用的是SinkDisposer.dispose()
3.SinkDisposer.dispose()对保存的2个属性分别调用dispose()并设置为nil,subscription保存的是外界创建序列时的闭包, 因此subscription.dispose()也是切断RxSwift与外界的关联.
_sink.dispose()调用保存的属性_cancel的dispose()，
4.RxSwift为了统一性，会对保存的属性都调用一次dispose()，如果有相互包含的属性,会有相互调用dispose()的情况。比如SinkDisposer.dispose(),会调用sink.dispose(),而执行sink.dispose()又将会执行SinkDisposer.dispose()
