销毁者的使用介绍

Observable从创建到销毁流程

1. 首先，一个 Observable 序列被创建出来后它不会马上就开始被激活从而发出 Event事件，而是要等到它被某个订阅者订阅了才会激活它。
2. 而 Observable 序列被激活之后要一直等到它发出了 .error 或者 .completed 的 event事件 后，它才被销毁、终结。

dispose()方法

1. 使用dispose()方法我们可以手动取消掉一个订阅行为。
2. 如果我们觉得这个订阅结束了不再需要了，就可以调用dispose()方法把这个订阅给销毁掉，防止内存泄漏。
3. 当一个订阅行为被 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

1. 除了 dispose() 方法之外，其实，我们更经常用到的应该是一个叫 DisposeBag 的对象来管理多个订阅行为的销毁处理：

• 我们可以把一个 DisposeBag 对象看成一个垃圾袋，把用过的订阅行为都放进去。
• 而这个 DisposeBag 就会在自己快要 dealloc 的时候，对它里面的所有订阅行为都调用 dispose() 方法。

2. 下面是一个简单的🌰：

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

代码里面关于销毁者相关的就是我们创建序列的回调闭包

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<Element>) {
    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老师是老司机，带你装逼，带你飞，都不带眨眼的。