RxJava(二)——原理与源码

RxJava除了要知道它的核心思想和基本概念我们还应该弄明白什么呢？必然是原理级别的啦，为什么RxJava可以使用链式调用，在源码中这个链式调用是怎么体现的？RxJava是如何实现线程切换的，以及为什么设置线程规则时subscribeOn只有第一次设置生效，而observeOn可以设置多次生效？RxJava2中的背压策略是什么?这些问题都是本章我们需要一一去研究弄明白的知识点。

一、RxJava调用流程：链式调用

熟悉或者写过构建者模式的同学可能会更清楚一点链式调用。就是每执行一个方法都会返回一个对应的对象来达到依次调用的效果。通常构建者模式都是返回Builder自身，最后执行build方法时才返回构建完成的实例对象。这一设计模式在Android源码中也能够随处可见，足以说明它的重要性。RxJava其实也同样采用了这种设计模式，只不过它在这种模式的基础上又结合了装饰器模式，两种模式结合在一起来达到链式调用的效果（也就是我们下面图解中的洋葱模型）。说这么多，大家还是懵逼的。下面我们通过图解可能会更好理解一点。

跟过源码的同学可能会发现Observable的很多操作符都会对应返回一个Observable对象，我们还是看图比较容易理解一些。

从上图就能狠清晰的看出来Observable.create()返回的是一个ObservableCreate的对象。那么这个ObservableCreate是个什么东西呢？看一下它的源码：

 通过源码就狠清楚知道，这个ObservableCreate同样是个Observable，而我们接下来再调用的操作符subscribeOn就是在这个Observable对象基础上调用的，同理subscribeOn、observeOn等操作符都会返回一个重新进行包装过后的新的Observable对象（也就是上图中的洋葱模型了），直到最后调用subcribe产生订阅。那么这种模型是如何实现订阅关系的呢？我们还是通过图来看更清晰一些，毕竟只看源码很枯燥的，看懂图片再去跟源码或许会轻松很多。

 从RxJava的订阅模型就能看出来，我们在代码中最后创建的观察者订阅的是最外层的Observable,而数据流（事件）最终是通过这种逐级传递的方式到达我们最内层的观察者。当然了，这里的逐级传递还涉及到了很多的知识点，如下面我们要讲的线程切换就是其中之一。

二、RxJava的线程切换原理

（1）线程调度器

在RxJava中进行线程控制都是通过设置线程调度器来实现的，每一种调度器都有着其独特的功能特性和使用场景。

调度器类型	效果
Schedulers.computation()	用于计算任务，如事件循环或和回调处理，不要用于IO操作(IO操作请使用Schedulers.io())；默认线程数等于处理器的数量
Schedulers.from(executor)	使用指定的Executor作为调度器
Schedulers.immediate( )	在当前线程立即开始执行任务
Schedulers.io( )	用于IO密集型任务，如数据库读写，网络请求等
Schedulers.newThread( )	为每个任务创建一个新线程
Schedulers.trampoline( )	当其它排队的任务完成后，在当前线程排队开始执行
AndroidSchedulers.mainThread()	用于Android的UI更新操作，任务执行在主线程中，一帮设置为observeOn的调度器，用于下游接收到数据流后更新UI

 （2）如何实现线程切换

 上图是我扣来的一个RxJava整个调用流程以及线程切换流程。如果有同学能一眼就看明白这张图，那就真的很厉害了。反正我一开始是没看明白的，跟了狠久的源码才稍微弄明白了一点点。那么下面我就根据这张图以及源码来讲一下我弄明白的那一点点。这里的map等操作符都会返回一个新包装的Observable对象前面已经说过了，那么我们来从下往上看它是如何实现线程切换的。

a、observeOn() 的线程切换原理

根据运行流程来看 observeOn() 执行后是得到 ObservableObserveOn 对象，那么当 ObservableObserveOn 绑定监听者的时候要运行 subscribe() 方法

public final void subscribe(Observer observer) {
    ObjectHelper.requireNonNull(observer, "observer is null");
    try {
        observer = RxJavaPlugins.onSubscribe(this, observer);
        ObjectHelper.requireNonNull(observer, "Plugin returned null Observer");
        //调用 subscribeActual()
        subscribeActual(observer);
    } catch (NullPointerException e) { // NOPMD
        throw e;
    } catch (Throwable e) {
        ...
    }
}
这里的subscribeActual方法里面又干了什么呢？
protected void subscribeActual(Observer observer) {
    if (scheduler instanceof TrampolineScheduler) {
        source.subscribe(observer);
    } else {
        //scheduler 是传进来的线程调度对象，如 Schedulers.io() 、AndroidSchedulers.mainThread() 等,这里调用了 createWorker() 方法暂时看一下就好稍后分析 RxAndroid 会说明 
        Scheduler.Worker w = scheduler.createWorker();
        //我们看到他把 w 参数传进去了
        source.subscribe(new ObserveOnObserver(observer, w, delayError, bufferSize));
    }
}

 从上述源码我们可以看到 ObservableObserveOn 是被 ObserveOnObserver 监听的，所以收到通知也是由 ObserveOnObserver 作出响应，接下来我们假设当 Rxjava 发送 onNext 通知时会调用 ObserveOnObserver 的 onNext() 方法 (当然如果是 onComplete()、onError() 等也是一样的逻辑 )，然后我们来看一看 ObserveOnObserver 的 onNext() 方法

@Override
public void onNext(T t) {
    if (done) {
        return;
    }
    if (sourceMode != QueueDisposable.ASYNC) {
        queue.offer(t);
    }
    //切换线程
    schedule();
}

void schedule() {
    if (getAndIncrement() == 0) {
        //直接调用了 worker 的 schedule 方法，需要注意的是这里他把自己传了进去
        worker.schedule(this);
    }
}

 现在我先把把 schedule(Runnable run) 贴出来

public Disposable schedule(@NonNull Runnable run) {
    return schedule(run, 0L, TimeUnit.NANOSECONDS);
}

1、我们看到这个他接收的参数是一个 Runnable，这是怎么回事呢，我们看一下 ObserveOnObserver 对象，他不但实现了 Observer 接口并且也实现了 Runnable 接口

 2、接下看，继续调用 schedule( Runnable action, long delayTime, TimeUnit unit) 方法，但是这个方法是个抽象方法，这里我们就假设这里这个 worker 是 IO 线程，所以我直接贴 IoScheduler 的代码了

public Disposable schedule(@NonNull Runnable action, long delayTime, @NonNull TimeUnit unit) {
     if (tasks.isDisposed()) {
         // don't schedule, we are unsubscribed
         return EmptyDisposable.INSTANCE;
     }
     return threadWorker.scheduleActual(action, delayTime, unit, tasks);
}

 然后再贴一下 scheduleActual 的方法

public ScheduledRunnable scheduleActual(final Runnable run, long delayTime, @NonNull TimeUnit unit, @Nullable DisposableContainer parent) {
    Runnable decoratedRun = RxJavaPlugins.onSchedule(run);
    //就是个 Runnable
    ScheduledRunnable sr = new ScheduledRunnable(decoratedRun, parent);
        
    if (parent != null) {
        if (!parent.add(sr)) {
            return sr;
        }
    }

    Future f;
    try {
        //判断延迟时间，然后使用线程池运行 Runnable。看到这里是不是有点熟悉呢？有没有感觉和AsyncTask有点像呢，都是利用线程池来完成线程间的切换。
        if (delayTime <= 0) {
            f = executor.submit((Callable