作者： @怪盗kidou
如需转载需在明显位置保留作者信息及原文链接
如果博客中有不恰当之处欢迎留言交流http://www.jianshu.com/p/4e78d447394e

1、前言

一年多没有写新博客了，今天又来水一篇，算是对《你真的会用RxJava么?RxJava线程变换之observeOn与subscribeOn》这篇博客做一个补充，如果你自己有想过RxJava怎么实现线程变换以及读过RxJava源码的同学想必是知道今天主题的答案的。如果你不确定那么请继续往下看。

既然之前的文章有讲过为啥我时隔一年多还要再写一篇文章来说明呢? 原因有两个：

我看到部分讲 RxJava 线程切换的博客里针对这点说得并不对
之前的文章里讲得并不怎么详细

当然按照惯列先给结论：并不是只有第一次才有效。

2、RxJava如何运作

最开始接触到RxJava的时候感觉到最神奇的是线程变换，也就是 subscribeOn 以及 observeOn 操作符，还是在一条调用链上就搞定了，我当时就在想我能不能自己也实现一个这样的东西呢，所以在本地建一个叫 DeRxJava 的项目，在没有看RxJava源码的情况下自己来实现一下 subscribeOn 和 observeOn ，当然实际上实现原理也非常简单，下面我们就分析一下。

为方便理解后面的内容，我以下面代码为例给大家进行说明，看看是RxJava是如何运作的。

Observable
        .just(0)
        .observeOn(Schedulers.computation())
        .map(i -> i + 1)
        .subscribeOn(Schedulers.newThread())
        .subscribe(System.out::println);

请看下面的示意图（向上的箭头表示订阅操作的方向，向下的箭头表示数据流向，箭头的颜色表示所在的线程，曲折的箭头表示发生了线程切换）。

RxJava线程切换示意图1

该图我们应该就能看出RxJava的运作方式了，如果不能的我作一点提示，这里每调用一个操作符时都会创建一个新的Observable出来，每一个操作符产生的新Observable都会向上层的Observable注册自己的回调。 subscribeOn 和 observeOn 的实现方法：subscribeOn 的原理就是在指定线程中向上游订阅（白话就是在指定线程中去调上游的subscribe方法），observeOn 的原理是收到数据后在指定的线程中调用下游的回调方法（onNext/onError/onComplete等），而数据又总是在发生订阅关系之后才被收到，所以 subscribeOn 即使出现 observeOn 之后也能保证数据源运行的线程。

3、为什么subscribeOn不是只有第一次才有效

那多次调用subscribeOn只有第一次生效这种说法是怎么来的呢，我们再以下面的代码为例，看看RxJava的运作方式。

Observable
        .just(0)
        .observeOn(Schedulers.computation())
        .map(i -> i + 1)
        .subscribeOn(Schedulers.newThread())
        .subscribeOn(Schedulers.io()) // 多了这一行
        .subscribe(System.out::println);

根据上面的代码，从表面上看 just(0) 确定是发生在第一次调用 subscribeOn 时指定的 newThread 中，但第二个
subscribeOn 就真的没有效果? 其实它确实生效了，只是又被上游的 subscribeOn 切换到了别的线程而已，具体见下图

RxJava线程切换示意图2

4、subscribeOn和observeOn的实现源码

为让大家更好的理解上面的图，我从RxJava 2.1.5 摘取了这两个操作符的源码进行了精简并添加了说明。

subscribeOn 的实现源码：

@Override
// 这个方法会在下游调用subscribe方法时被调用
public void subscribeActual(final Observer<? super T> s) {
    final SubscribeOnObserver<T> parent = new SubscribeOnObserver<T>(s);
    s.onSubscribe(parent);
    // 这里并没有直接订阅，而是先进行了线程变换（scheduler.scheduleDirect）
    // 大白话：在线程变换后才掉用subscribe方法
    parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));
}

static final class SubscribeOnObserver<T> extends AtomicReference<Disposable> implements Observer<T>, Disposable {
    // 其它代码已经被精简，只以 onNext为例
    @Override
    public void onNext(T t) {
        // 收到数据后不进行线程变换
        actual.onNext(t);
    }
}

final class SubscribeTask implements Runnable {
    // 其它代码已经被精简
    @Override
    public void run() {
        // 这个方法会被指定的scheduler调用，向上游订阅时线程已经发生了变化
        // 所以保证了上游所运行的线程
        source.subscribe(parent);
    }
}

observeOn 的实现源码：

@Override
protected void subscribeActual(Observer<? super T> observer) {
    if (scheduler instanceof TrampolineScheduler) {
        source.subscribe(observer);
    } else { // 直接向上游订阅数据，不进行线程切换,切换操作是在回调里进行的，见下面的onNext
        Scheduler.Worker w = scheduler.createWorker();
        source.subscribe(new ObserveOnObserver<T>(observer, w, delayError, bufferSize));
    }
}

static final class ObserveOnObserver<T> extends BasicIntQueueDisposable<T> implements Observer<T>, Runnable {
@Override
public void onNext(T t) {
    if (done) {
        return;
    }
    // 这里选把数据放到队列中
    if (sourceMode != QueueDisposable.ASYNC) {
        queue.offer(t);
    }
    // 在schedule方法里进行线程切换并把数据循环取出
    // 回调给下游，这样下游就会在指定的线程中收到数据
    // 大白话：在回调里切换线程
    schedule();
}

5、结语

最后就是告诉大家不要被表象所迷惑，就拿这个 subscribeOn 来说，只要你知道实现的方式就是在指定线程中去向上级订阅你就应该想到正常情况下 subscribeOn 并不知道上游有没有其它的 subscribeOn 操作符，所以每次它都只能老老实实的去指定的线程中去向上游订阅。

Ps:写个博客还真不容易，就这么一篇小小的文章搞了2、3天，想了很多例子都被去掉了，最后还是直接画了两个图来展示，如果你觉得有用的话请点赞、分享、打赏，如果还有疑问话请直接评论，我虽然并不常更新博客但还是有一直留意博客上的评论和私信的，这次就到这儿。