RxSwift - Schedulers

Scheduler

简单来说Scheduler就是进程执行的上下文（也可以说程序执行的上下文）。上下文（context）可以是一个线程（thread），一个派发列队（dispatch queue），或者是用于OperationQueueScheduler中的NSOperation。这里有一个好例子说明调度者怎样被使用：

由上图可知，我们可能在后台调度者中（Background Scheduler）进行网络请求，然后缓存数据。并传递数据给所有的订阅者，大多数时候会回到MainScheduler,MainScheduler位于主线程的顶部。因为更新UI操作，必须在主线程。所以会切换到MainScheduler。注意：调度者（Scheduler）不是线程。

几种内嵌Scheduler（Builtin schedulers）

CurrentThreadScheduler (Serial scheduler)

当前线程的调度者，这也是默认的调度者用于产生元素。

MainScheduler (Serial scheduler)

MainScheduler是主线程的一部分，这个调度者是经常用于处理用户界面的改变（即执行UI工作）和执行一些高优先级的任务。长时间任务不应该在该调度者中执行，比如：向服务器请求数据，其他繁重的任务。除此之外，如果你执行链式响应（side effects）来更新UI，你必须转换到MainScheduler，保证屏幕UI更新成功。MainScheduler也用于执行所有的计算，当使用Units、Driver。Driver确保了计算经常被执行在MainScheduler，让你有能力直接绑定数据到用户界面。下面是MainScheduler类的部分源码：

public final class MainScheduler : SerialDispatchQueueScheduler {

    private let _mainQueue: DispatchQueue

    /// Initializes new instance of `MainScheduler`.
    public init() {
        _mainQueue = DispatchQueue.main
        super.init(serialQueue: _mainQueue)
    }

    /// Singleton instance of `MainScheduler`
    public static let instance = MainScheduler()
}

由上面代码可知，MainScheduler是继承于SerialDispatchQueueScheduler，有instance单例，并且初始化时指定了运行线程为主线程（DispatchQueue.main），我们经常使用MainScheduler.instance来获取主线程并且配合observeOn操作符进行使用。

SerialDispatchQueueScheduler (Serial scheduler)

SerialDispatchQueueScheduler管理着串行派发列队（serial DispatchQueue）的抽象工作。它将确保即使是并发派发列队（concurrent dispatch queue ）被传递，也将被转换为串行。在使用observeOn操作符的时候，这个调度者有几个非常大的优势。你能够使用该调度者处理后台任务，而且使用串行的方式更好的执行。例如：如果你有一个应用跟服务端进行交流（as in a Firebase or GraphQL application），你可能想避免派发多个，同时的请求，这会给服务端导致太大的压力。该调度者是完成满足你的工作就像一个串行任务列队一样，按顺序执行。

ConcurrentDispatchQueueScheduler (Concurrent scheduler)

ConcurrentDispatchQueueScheduler跟SerialDispatchQueueScheduler有些类似，也是管理DispatchQueue的抽象工作.主要的区别是这次不是串行列队而是一个并发列队。当使用observeOn的时候，该调度者并不算最佳选择。ConcurrentDispatchQueueScheduler是多任务、长耗时、需要同步执行任务的首选。

OperationQueueScheduler (Concurrent scheduler)

OperationQueueScheduler非常相似于ConcurrentDispatchQueueScheduler，但是并不是跟DispatchQueue一起工作，而是与NSOperationQueue一起工作。有时，你需要更多的对于并发的工作控制权限，但是你不能够在ConcurrentDispatchQueueScheduler进行操作，可以选择使用OperationQueueScheduler。

如果需要很好的设置最大数量的并发工作，OperationQueueScheduler是很好的选择。因为你能够使用maxConcurrentOperationCount来设置最大的操作数量

TestScheduler

非常特殊，它是用于测试的，所以注意了，不能够在正常的开发中使用，应该仅仅是用于测试，它是RxTest库的一部分。

注意：有趣的事情是如果传递并发列队(concurrent queue)到串行调度者(serial scheduler)，RxSwift将确保并发列队变成串行列队(serial queue)。同理：如果传递串行列队到并发调度者，也会将串行列队变成并发列队（concurrent queue）

转换调度者（Switching schedulers）

在rx中一个最重要的事情之一就是可以有能力在任意时候转换调度者（Switching schedulers）。没有任何的限制，除了一个被强加的，由内部进程生成事件。

在线程这部分主要有两个操作符：observeOn 和 subscribeOn ，常用的还是 observeOn 。observeOn是ObservableType扩展中的一个方法：

extension ObservableType {
    /**
        Wraps the source sequence in order to run its observer callbacks on the specified scheduler.
        
        This only invokes observer callbacks on a `scheduler`. In case the subscription and/or unsubscription
        actions have side-effects that require to be run on a scheduler, use `subscribeOn`.
  
        - seealso: [observeOn operator on reactivex.io](http://reactivex.io/documentation/operators/observeon.html)
        - parameter scheduler: Scheduler to notify observers on.
        - returns: The source sequence whose observations happen on the specified scheduler.
        */
    public func observeOn(_ scheduler: ImmediateSchedulerType) -> RxSwift.Observable<Self.E>
}

调用 observeOn 指定接下来的操作在哪个线程,也可以理解为在哪个scheduler监听Observable.一个比较典型的例子：在后台发起网络请求，然后解析数据，最后在主线程刷新页面。我们可以先使用subscribeOn切换到后台发送请求并解析数据，在使用observeOn切换回到主线程更新页面。或者使用两次observeOn

  sequence1
            .observeOn(backgroundScheduler)
            .map { n in
                print("This is performed on the background scheduler")
            }
            .observeOn(MainScheduler.instance)
            .map { n in
                print("This is performed on the main scheduler")
        }

调用 subscribeOn 决定订阅者的操作执行在哪个线程。对于subscribeOn：

extension ObservableType {
    /**
        Wraps the source sequence in order to run its subscription and unsubscription logic on the specified 
        scheduler. 
        
        This operation is not commonly used.
        This only performs the side-effects of subscription and unsubscription on the specified scheduler. 
        In order to invoke observer callbacks on a `scheduler`, use `observeOn`.
    
        - seealso: [subscribeOn operator on reactivex.io](http://reactivex.io/documentation/operators/subscribeon.html)
        - parameter scheduler: Scheduler to perform subscription and unsubscription actions on.
        - returns: The source sequence whose subscriptions and unsubscriptions happen on the specified scheduler.
        */
    public func subscribeOn(_ scheduler: ImmediateSchedulerType) -> RxSwift.Observable<Self.E>
}

当然，如果我们没有明确调用这两个操作，后面的操作都是在当前线程执行的。对于调度者使用的简单事例可以看这里。

参考：

官方文档