销毁者的使用介绍
Observable从创建到销毁流程
- 首先，一个
Observable序列被创建出来后它不会马上就开始被激活从而发出Event事件，而是要等到它被某个订阅者订阅了才会激活它。- 而
Observable序列被激活之后要一直等到它发出了.error或者.completed的event事件 后，它才被销毁、终结。
dispose()方法
- 使用
dispose()方法我们可以手动取消掉一个订阅行为。- 如果我们觉得这个订阅结束了不再需要了，就可以调用
dispose()方法把这个订阅给销毁掉，防止内存泄漏。- 当一个订阅行为被
dispose了，那么之后observable如果再发出event事件，这个已经dispose的订阅就收不到消息了。
下面是一个简单的使用样例：
let observable = Observable.of("A", "B", "C")
//使用subscription常量存储这个订阅方法
let subscription = observable.subscribe { event in
print(event)
}
//调用这个订阅的dispose()方法
subscription.dispose()
运行结果：
next(A)
next(B)
next(C)
completed
DisposeBag
- 除了
dispose()方法之外，其实，我们更经常用到的应该是一个叫DisposeBag的对象来管理多个订阅行为的销毁处理：
- 我们可以把一个
DisposeBag对象看成一个垃圾袋，把用过的订阅行为都放进去。- 而这个
DisposeBag就会在自己快要dealloc的时候，对它里面的所有订阅行为都调用dispose()方法。
- 下面是一个简单的：
let disposeBag = DisposeBag()
//第1个Observable，及其订阅
let observable1 = Observable.of("A", "B", "C")
observable1.subscribe { event in
print(event)
}.disposed(by: disposeBag)
//第2个Observable，及其订阅
let observable2 = Observable.of(1, 2, 3)
observable2.subscribe { event in
print(event)
}.disposed(by: disposeBag)
运行结果：
next(A)
next(B)
next(C)
completed
next(1)
next(2)
next(3)
completed
销毁者的探索
初探
首先，我们先来看一段代码：
// 创建序列
let ob = Observable.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()
调用
在之前的流程中，我们是在序列的回调闭包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 方法也在预料之中，分别销毁。
再看下去：
let disposer = SinkDisposer()
let sinkAndSubscription = self.run(observer, cancel: disposer)
disposer.setSinkAndSubscription(sink: sinkAndSubscription.sink,
subscription: sinkAndSubscription.subscription)
// 返回销毁者
return disposer
可以看到，SinkDisposer关键销毁者，进入到self.run(observer, cancel: disposer)。
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
再看：
// 创建 sink 保存了销毁者
let sink = AnonymousObservableSink(observer: observer, cancel: cancel)
// 中间流程省略。。。。
func on(_ event: Event) {
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()。- 在初始化初期我们保留的两个属性的操作
sink.dispose() + self._sink = nil & subscription.dispose() + self._subscription = nil执行相关释放和销毁。
最后，中了cooci老师的毒，有点飘了，这后部分的内容来自cooci老师的RxSwift销毁者-dispose源码解析，大家多多关注哦，cooci老师是老司机，带你装逼，带你飞，都不带眨眼的。