調(diào)度環(huán)境

CurrentThreadScheduler:當前線程的Scheduler.（默認）
MainScheduler:主線程，繼承自SerialDispatchQueueScheduler
SerialDispatchQueueScheduler：封裝了GCD串行隊列
ConcurrentMainScheduler:封裝GCD的并行隊列
OperationQueueScheduler:封裝NSOperationQueue

調(diào)度流程

1.observeOn 串行隊列：ObserveOnSerialDispatchQueue

創(chuàng)建一個訂閱到串行隊列的訂閱

 Observable.of(0,1,2) //ObservableSequence
//ObserveOnSerialDispatchQueue
.observeOn(SerialDispatchQueueScheduler.init(internalSerialQueueName: "serial"))
.subscribe { (value) in
                print("observeOn", value.element, Thread.current)
        }
.disposed(by: disposebag)

SerialDispatchQueueScheduler.init 創(chuàng)建了一個DispatchQueue
observeOn 創(chuàng)建了ObserveOnSerialDispatchQueue,保存了元序列 ObservableSequence和調(diào)度者scheduler

 if let scheduler = scheduler as? SerialDispatchQueueScheduler {
     return ObserveOnSerialDispatchQueue(source: self.asObservable(), scheduler: scheduler)
 }

  let observer = AnonymousObserver { e in
                on(e)
            }
            return self.asObservable().subscribe(observer)

創(chuàng)建 AnonymousObserver類，保存元訂閱閉包
ObserveOnSerialDispatchQueue繼承自Producer
執(zhí)行Producer的subscribe方法
首先判斷CurrentThreadScheduler.isScheduleRequired == true
則把CurrentThreadScheduler.isScheduleRequired = false
并執(zhí)行以下閉包

 return CurrentThreadScheduler.instance.schedule(()) { _ in
                let disposer = SinkDisposer()
                let sinkAndSubscription = self.run(observer, cancel: disposer)
                disposer.setSinkAndSubscription(sink: sinkAndSubscription.sink, subscription: sinkAndSubscription.subscription)

                return disposer

執(zhí)行子類ObserveOnSerialDispatchQueue.run

 let sink = ObserveOnSerialDispatchQueueSink(scheduler: self.scheduler, observer: observer, cancel: cancel)
        let subscription = self.source.subscribe(sink)
        return (sink: sink, subscription: subscription)

創(chuàng)建ObserveOnSerialDispatchQueueSink
self.source 即ObservableSequence:Producer
調(diào)用Producer.subscribe(sink)
由于CurrentThreadScheduler.isScheduleRequired = false,執(zhí)行以下代碼

if !CurrentThreadScheduler.isScheduleRequired {
            // The returned disposable needs to release all references once it was disposed.
            let disposer = SinkDisposer()
            let sinkAndSubscription = self.run(observer, cancel: disposer)
            disposer.setSinkAndSubscription(sink: sinkAndSubscription.sink, subscription: sinkAndSubscription.subscription)

            return disposer
        }

調(diào)用子類ObservableSequence.run

 let sink = ObservableSequenceSink(parent: self, observer: observer, cancel: cancel)
        let subscription = sink.run()
        return (sink: sink, subscription: subscription)

創(chuàng)建 ObservableSequenceSink 執(zhí)行run()

 func run() -> Disposable {
        return self._parent._scheduler.scheduleRecursive(self._parent._elements.makeIterator()) { iterator, recurse in
            var mutableIterator = iterator
            if let next = mutableIterator.next() {
                self.forwardOn(.next(next))
                recurse(mutableIterator)
            }
            else {
                self.forwardOn(.completed)
                self.dispose()
            }
        }
    }

當前調(diào)度者調(diào)度執(zhí)行

  let recursiveScheduler = RecursiveImmediateScheduler(action: action, scheduler: self)
        
        recursiveScheduler.schedule(state)

forwardOn 回到ObserveOnSerialDispatchQueueSink.onCore
手動創(chuàng)建的串行隊列開始調(diào)度

 override func onCore(_ event: Event<Element>) {
        _ = self.scheduler.schedule((self, event), action: self.cachedScheduleLambda!)
    }

最終回到異步執(zhí)行action(state)

func schedule<StateType>(_ state: StateType, action: @escaping (StateType) -> Disposable) -> Disposable {
        let cancel = SingleAssignmentDisposable()

        self.queue.async {
            if cancel.isDisposed {
                return
            }
            cancel.setDisposable(action(state))
        }
        return cancel
    }