RxJava 2 源码解析之线程切换

在分析RxJava2的线程切换源码之前，再看看在上一篇RxJava 2 源码解析之创建-订阅-变换-发布里总结的流程图：

rxjava2-create-subscribe-emit-flow.png

其实对RxJava2是如何实现各种Observable-Observer之间的串联的之后，就可以先按照我们的常规理解来猜测一下它会怎么实现：

• 我们的subscribeOn()是在整个订阅链条中被最后一个最接近它的Observable调用起来的，那么是不是只需要这个Observable把这个方法的执行放到指定线程中就行了？
• 根据RxJava2的套路，执行subscribeOn()的时候，一定又会创建一个名字也会按照套路起的ObservableSubscribeOn，那么一定会是它在subscribeActual()中把它的source也就是ObservableCreate的subscribe()方法放到指定线程中去执行
• 而对于observeOn()，按照我们总结的事件发布链，除了最后一个Observable之外，每个Observable它的实际Observer都是下一个Observable的Observer，那么当我们希望我们的某个Observer在指定的线程执行的时候，是不是只要它的上一个将它放进去就行了？
  而这个“上一个Observer”，不就是我们的observeOn()创建的吗？所以，控制下一个Observer执行线程的，应该就是ObserveOnObserver。

下面看看RxJava具体究竟是如何实现的吧！

一段最简单的RxJava2线程切换的代码：

        Observable
                .create(new ObservableOnSubscribe() {
                    @Override
                    public void subscribe(ObservableEmitter emitter) throws Exception {

                        Log.d("RxJava2", "subscribe " + Thread.currentThread().getName());
                        emitter.onNext(1);

                    }
                })
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Observer() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d("RxJava2", "onSubscribe " + Thread.currentThread().getName());
                    }

                    @Override
                    public void onNext(Integer integer) {
                        Log.d("RxJava2", "onNext " + Thread.currentThread().getName());
                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onComplete() {

                    }
                });

我们先看subscribeOn()过程的切换

subscribeOn

---

来看看它是怎么完成线程切换的：

    public final Observable subscribeOn(Scheduler scheduler) {
        ObjectHelper.requireNonNull(scheduler, "scheduler is null");
        return RxJavaPlugins.onAssembly(new ObservableSubscribeOn(this, scheduler));
    }

嗯，还是跟之前的分析看到的一样，都是这个套路：

创建了一个ObservableXX

重点关注ObservableSubscribeOn：

public final class ObservableSubscribeOn extends AbstractObservableWithUpstream {
    final Scheduler scheduler;

    public ObservableSubscribeOn(ObservableSource source, Scheduler scheduler) {
        super(source);
        this.scheduler = scheduler;
    }

    @Override
    public void subscribeActual(final Observer s) {
        final SubscribeOnObserver parent = new SubscribeOnObserver(s);

        s.onSubscribe(parent);

        parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));
    }


    static final class SubscribeOnObserver extends AtomicReference implements Observer, Disposable {

        private static final long serialVersionUID = 8094547886072529208L;
        final Observer actual;

        final AtomicReference s;

        SubscribeOnObserver(Observer actual) {
            this.actual = actual;
            this.s = new AtomicReference();
        }

        @Override
        public void onSubscribe(Disposable s) {
            DisposableHelper.setOnce(this.s, s);
        }

        @Override
        public void onNext(T t) {
            actual.onNext(t);
        }

        @Override
        public void onError(Throwable t) {
            actual.onError(t);
        }

        @Override
        public void onComplete() {
            actual.onComplete();
        }

        @Override
        public void dispose() {
            DisposableHelper.dispose(s);
            DisposableHelper.dispose(this);
        }

        @Override
        public boolean isDisposed() {
            return DisposableHelper.isDisposed(get());
        }

        void setDisposable(Disposable d) {
            DisposableHelper.setOnce(this, d);
        }
    }

    final class SubscribeTask implements Runnable {
        private final SubscribeOnObserver parent;

        SubscribeTask(SubscribeOnObserver parent) {
            this.parent = parent;
        }

        @Override
        public void run() {
            source.subscribe(parent);
        }
    }

}

它有两个内部类，一个是以前的老套路：static的XXObserver，还多了一个实现了Runnable的SubscribeTask。

有了之前的经验，现在直接看subscribeActual()就好了，而且根据之前的猜测，它应该在这会有关于线程切换的内容，赶紧看看吧：

        final SubscribeOnObserver parent = new SubscribeOnObserver(s);

        s.onSubscribe(parent);

        parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));

果然，scheduler.scheduleDirect(new SubscribeTask(parent))这里一眼就能看出来，它专门为在某个线程执行的subscribeTask创建了一个任务，

        @Override
        public void run() {
            source.subscribe(parent);
        }

看看上面的源码，它其实就是一个Runnable嘛！那么这个scheduler就一定是负责让这个runnable执行起来的家伙了。

不过，等等，这一行是干嘛的？

        s.onSubscribe(parent);

根据RxJava2的链条来说，它在这里调用了Observer的onSubscribe，那么在这个Observable之前的结点不是还有ObservableCreate吗？它也是会调用Observer的onSubscribe方法的呀，这不会造成重复调用吗？

再想想，不对，ObservableCreate调用的onSubscribe()，最终都会通过整个Observable链往下传递，那么我们这个SubscribeOnObserver不就在它的下面吗？会不会是它拦截了这个传递过程避免重复调用呢？

于是回头看看它的源码：

        @Override
        public void onSubscribe(Disposable s) {
            DisposableHelper.setOnce(this.s, s);
        }

果不其然，这小子没有再往下传递了。嗯，解决了这个疑惑，接着我们之前的schedual流程：scheduler.scheduleDirect(xxx)
Schedular.java

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

OK，继续点：

    public Disposable scheduleDirect(@NonNull Runnable run, long delay, @NonNull TimeUnit unit) {
        final Worker w = createWorker();

        final Runnable decoratedRun = RxJavaPlugins.onSchedule(run);

        DisposeTask task = new DisposeTask(decoratedRun, w);

        w.schedule(task, delay, unit);

        return task;
    }

这里的Worker是个抽象类，

    public abstract static class Worker implements Disposable {

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

        @NonNull
        public abstract Disposable schedule(@NonNull Runnable run, long delay, @NonNull TimeUnit unit);

        public long now(@NonNull TimeUnit unit) {
            return unit.convert(System.currentTimeMillis(), TimeUnit.MILLISECONDS);
        }

        //... 省略
    }

可以看出，它才是Scheduler中真正负责线程调度的角色。

而DisposeTask实现了Disposable和Runnable，它只是对我们的Runnable进行了一层包装。

createWorker也是个抽象方法，具体还是由我们切换的线程类型时所指定的Scheduler来实现的。

image.png

可以看到RxJava2有这么多个Scheduler，我们这里
subscribeOn是在io线程，所以就去看看这个IoScheduler：

    public Worker createWorker() {
        return new EventLoopWorker(pool.get());
    }

这个EventLoopWorker的schedule()方法：

        public Disposable schedule(@NonNull Runnable action, long delayTime, @NonNull TimeUnit unit) {
           //...省略

            return threadWorker.scheduleActual(action, delayTime, unit, tasks);
        }

这里的threadWorker继承自NewThreadWorker，它也是Scheduler.Worker的子类，我们直接看看NewThreadWorker：

    @NonNull
    public ScheduledRunnable scheduleActual(final Runnable run, long delayTime, @NonNull TimeUnit unit, @Nullable DisposableContainer parent) {
        Runnable decoratedRun = RxJavaPlugins.onSchedule(run);

        ScheduledRunnable sr = new ScheduledRunnable(decoratedRun, parent);

        if (parent != null) {
            if (!parent.add(sr)) {
                return sr;
            }
        }

        Future f;
        try {
            if (delayTime <= 0) {
                f = executor.submit((Callable