Rxjava的线程调度源码解析

代码调用

        Observable.just(1)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer() {
                    @Override
                    public void accept(Integer integer) throws Exception {

                    }
                });

直接进入主题，先看subscribe中调用了哪些方法

    //Observable.java
    public final Disposable subscribe(Consumer onNext) {
        return subscribe(onNext, Functions.ON_ERROR_MISSING, Functions.EMPTY_ACTION, Functions.emptyConsumer());
    }

    public final Disposable subscribe(Consumer onNext, Consumer onError,
            Action onComplete, Consumer onSubscribe) {
        ObjectHelper.requireNonNull(onNext, "onNext is null");
        ObjectHelper.requireNonNull(onError, "onError is null");
        ObjectHelper.requireNonNull(onComplete, "onComplete is null");
        ObjectHelper.requireNonNull(onSubscribe, "onSubscribe is null");

        LambdaObserver ls = new LambdaObserver(onNext, onError, onComplete, onSubscribe);

        subscribe(ls);

        return ls;
    }

    public final void subscribe(Observer observer) {
        ObjectHelper.requireNonNull(observer, "observer is null");
        try {
            observer = RxJavaPlugins.onSubscribe(this, observer);

            ObjectHelper.requireNonNull(observer, "The RxJavaPlugins.onSubscribe hook returned a null Observer. Please change the handler provided to RxJavaPlugins.setOnObservableSubscribe for invalid null returns. Further reading: https://github.com/ReactiveX/RxJava/wiki/Plugins");

            subscribeActual(observer);
        } catch (NullPointerException e) { // NOPMD
            throw e;
        } catch (Throwable e) {
            Exceptions.throwIfFatal(e);
            // can't call onError because no way to know if a Disposable has been set or not
            // can't call onSubscribe because the call might have set a Subscription already
            RxJavaPlugins.onError(e);

            NullPointerException npe = new NullPointerException("Actually not, but can't throw other exceptions due to RS");
            npe.initCause(e);
            throw npe;
        }
    }
    //最终调用了Observable的subscribeActual方法
    protected abstract void subscribeActual(Observer observer);

接下来我们看下subscribeOn方法中进行了什么操作

    //Observable.java
    public final Observable subscribeOn(Scheduler scheduler) {
        ObjectHelper.requireNonNull(scheduler, "scheduler is null");
        //这里返回了一个ObservableSubscribeOn对象，参考RxJavaPlugins.onAssembly方法，
        //返回的值就是传入的值，再根据流式调用，
        //即上面分析调用的subscribeActual方法，即是ObservableSubscribeOn的subscribeActual方法
        return RxJavaPlugins.onAssembly(new ObservableSubscribeOn(this, scheduler));
    }

接下来我们看ObservableSubscribeOn的subscribeActual方法

//ObservableSubscribeOn.java
    public void subscribeActual(final Observer observer) {
        final SubscribeOnObserver parent = new SubscribeOnObserver(observer);

        observer.onSubscribe(parent);
        //这里生成了一个SubscribeTask，查看源码可知实现了Runnable接口
        //这里调用了scheduler.scheduleDirect
        parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));
    }

看下scheduler.scheduleDirect，再次之前，我们先看下传入的Scheduler.io
查看传入的Schedule

    public static Scheduler io() {
        //  这里查看下IO
        return RxJavaPlugins.onIoScheduler(IO);
    }
 //new IOTask
IO = RxJavaPlugins.initIoScheduler(new IOTask());

    static final class IOTask implements Callable {
        @Override
        public Scheduler call() throws Exception {
            return IoHolder.DEFAULT;
        }
    //由此可见，最后Schedulers.io就是IoScheduler
    static final class IoHolder {
        static final Scheduler DEFAULT = new IoScheduler();
    }

    //scheduler
    public Disposable scheduleDirect(@NonNull Runnable run, long delay, @NonNull TimeUnit unit) {
        //这里生成一个Worker，但是createWorker是一个虚方法，有上可知
        //这里调用了IoScheduler.createWorker，生成EventLoopWorker对象
        final Worker w = createWorker();

        final Runnable decoratedRun = RxJavaPlugins.onSchedule(run);
        
        DisposeTask task = new DisposeTask(decoratedRun, w);
        //调用了EventLoopWorker.schedule
        w.schedule(task, delay, unit);

        return task;
    }

接下来看EventLoopWorker

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

真正进入线程调度的代码，在NewThreadWorker中

    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) {
                //executor是一个线程池
                f = executor.submit((Callable