Retrofit2+rxjava2源码解析(二)：rxjava2源码解析

上一篇讲了retrofit2的原理，这一篇咱们重点讲讲rxjava2的实现原理。不过呢，由于rxjava2博大精深，这里篇幅有限，而且精力有限，所以这里只讲以下几个点：
1.上游被观察者Observable的创建
2.subscribeOn如何初始化调度线程者
3.observeOn如何初始化调度线程者
4.下游观察者的创建，上游被观察者的订阅事件，subscribeOn如何调度上游被观察者线程以及observeOn如何调度下游观察者线程

        //第一步
        Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter e) throws Exception {
                //log1
                LogUtil.d("subscribe : " + Thread.currentThread().getName());
                e.onNext("a");
                e.onComplete();
            }
        }).subscribeOn(Schedulers.io())//第二步
        .observeOn(AndroidSchedulers.mainThread())//第三步
        .subscribe(new Observer() {

            @Override
            public void onSubscribe(Disposable d) {
                 //log2
                LogUtil.d("onSubscribe : " + Thread.currentThread().getName());
            }

            @Override
            public void onNext(String str) {
                 //log3
                LogUtil.d("onSubscribe : " + Thread.currentThread().getName());
            }

            @Override
            public void onError(Throwable e) {
                 //log4
                LogUtil.d("onSubscribe : " + Thread.currentThread().getName());
            }

            @Override
            public void onComplete() {
                 //log5
                LogUtil.d("onSubscribe : " + Thread.currentThread().getName());
            }
        });//第四步

---

一、上游被观察者Observable的创建:

首先进入Observable的create方法里面去：

    public static  Observable create(ObservableOnSubscribe source) {
        ObjectHelper.requireNonNull(source, "source is null");
        return RxJavaPlugins.onAssembly(new ObservableCreate(source));
    }

public final class RxJavaPlugins {
    ...代码省略...
    /**
     * Calls the associated hook function.
     * @param  the value type
     * @param source the hook's input value
     * @return the value returned by the hook
     */
    @SuppressWarnings({ "rawtypes", "unchecked" })
    @NonNull
    public static  Observable onAssembly(@NonNull Observable source) {
        Function f = onObservableAssembly;
        if (f != null) {
            return apply(f, source);
        }
        return source;
    }

    ...代码省略...
}

RxJavaPlugins.onAssembly 是个hook方法，在这里不做详细介绍，我们可以

RxJavaPlugins.onAssembly(new ObservableCreate(source))

直接看成

new ObservableCreate(source)

就可以了。
下面很多地方会有类似的调用，都可以以这种形式看待，就不在说明了。
这里就返回了ObservableCreate的对象，然后把source传了进来，这里的source便是一开始new出来的ObservableOnSubscribe对象。

二、subscribeOn如何初始化调度线程者

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

1.我们可以看出此时返回的是一个ObservableSubscribeOn对象，参数一个是this说明是第一步new出来的ObservableCreate对象，这个就是当前对象里面的source变量，第二个参数是scheduler即Schedulers.io()。
2.那么Schedulers.io()到底是什么呢，一起去看看吧：

    @NonNull
    public static Scheduler io() {
        return RxJavaPlugins.onIoScheduler(IO);
    }

public final class RxJavaPlugins {
    ...代码省略...

     /**
     * Calls the associated hook function.
     * @param defaultScheduler the hook's input value
     * @return the value returned by the hook
     */
    @NonNull
    public static Scheduler onIoScheduler(@NonNull Scheduler defaultScheduler) {
        Function f = onIoHandler;
        if (f == null) {
            return defaultScheduler;
        }
        return apply(f, defaultScheduler);
    }

    ...代码省略...
}

其实这也是个hook方法，所以返回的就是IO。再来看下IO是个什么东西

    static {
        SINGLE = RxJavaPlugins.initSingleScheduler(new SingleTask());

        COMPUTATION = RxJavaPlugins.initComputationScheduler(new ComputationTask());

        IO = RxJavaPlugins.initIoScheduler(new IOTask());

        TRAMPOLINE = TrampolineScheduler.instance();

        NEW_THREAD = RxJavaPlugins.initNewThreadScheduler(new NewThreadTask());
    }

上图所知，这是个静态块，在程序加载的时候就会初始化出来

    /**
     * Calls the associated hook function.
     * @param defaultScheduler a {@link Callable} which returns the hook's input value
     * @return the value returned by the hook, not null
     * @throws NullPointerException if the callable parameter or its result are null
     */
    @NonNull
    public static Scheduler initIoScheduler(@NonNull Callable defaultScheduler) {
        ObjectHelper.requireNonNull(defaultScheduler, "Scheduler Callable can't be null");
        Function, ? extends Scheduler> f = onInitIoHandler;
        if (f == null) {
            return callRequireNonNull(defaultScheduler);
        }
        return applyRequireNonNull(f, defaultScheduler);
    }

然后根据hook function可以得知返回的Scheduler就是
callRequireNonNull(defaultScheduler)返回的对象。这个defaultScheduler是个IOTask对象，看下面代码

    static final class IOTask implements Callable {
        @Override
        public Scheduler call() throws Exception {
            return IoHolder.DEFAULT;
        }
    }

    static final class IoHolder {
        static final Scheduler DEFAULT = new IoScheduler();
    }

IOTask有个重写方法call，返回的是IoHolder.DEFAULT即IoScheduler。那么这个call方法是什么时候调用的呢，其实就是上面的callRequireNonNull方法里面调用。

所以可以得出Schedulers.io()获取到的就是IoSchedulers对象。

三、observeOn如何初始化调度线程者

    @CheckReturnValue
    @SchedulerSupport(SchedulerSupport.CUSTOM)
    public final Observable observeOn(Scheduler scheduler) {
        return observeOn(scheduler, false, bufferSize());
    }
  
    @CheckReturnValue
    @SchedulerSupport(SchedulerSupport.CUSTOM)
    public final Observable observeOn(Scheduler scheduler, boolean delayError, int bufferSize) {
        ObjectHelper.requireNonNull(scheduler, "scheduler is null");
        ObjectHelper.verifyPositive(bufferSize, "bufferSize");
        return RxJavaPlugins.onAssembly(new ObservableObserveOn(this, scheduler, delayError, bufferSize));
    }

1.可以看出来这里返回的是一个ObservableObserveOn对象，这里的this参数就是第二步的ObservableSubscribeOn对象，这个就是当前对象里面的source变量。而这个scheduler参数就是传入的AndroidSchedulers.mainThread()，看名字大概能猜出来这是个主线程调度者
2.那么就随我进入AndroidSchedulers的代码里一探究竟吧：

public final class AndroidSchedulers {

    private static final class MainHolder {

        static final Scheduler DEFAULT = new HandlerScheduler(new Handler(Looper.getMainLooper()));
    }

    private static final Scheduler MAIN_THREAD = RxAndroidPlugins.initMainThreadScheduler(
            new Callable() {
                @Override public Scheduler call() throws Exception {
                    return MainHolder.DEFAULT;
                }
            });

    /** A {@link Scheduler} which executes actions on the Android main thread. */
    public static Scheduler mainThread() {
        return RxAndroidPlugins.onMainThreadScheduler(MAIN_THREAD);
    }
  ...代码省略...
}

mainThread方法里面返回的是MAIN_THREAD，而这个MAIN_THREAD是通过RxAndroidPlugins.initMainThreadScheduler返回的MainHolder.DEFAULT对象，也就是HandlerScheduler对象。这个对象传入了主线程的handler，用来调度线程。

四、下游观察者的创建，上游被观察者的订阅事件，subscribeOn如何调度上游被观察者线程以及observeOn如何调度下游观察者线程

最关键的一步来了，先上代码：

    @SchedulerSupport(SchedulerSupport.NONE)
    @Override
    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(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;
        }
    }

1.ObjectHelper.requireNonNull已经出现了很多次，其实就是为了判断是否为空用的
2.这里的observer就是传入的观察者，即刚刚在最外层new出来的observer。
3.这个时候进入subscribeActual方法，发现这是个抽象方法，那么是谁实现了这个方法呢。还记得我们现在的subscribe是谁调用的嘛，没错就是第三步返回的ObservableObserveOn对象，所以ObservableObserveOn实现了subscribeActual方法:

    @Override
    protected void subscribeActual(Observer observer) {
        if (scheduler instanceof TrampolineScheduler) {
            source.subscribe(observer);
        } else {
            Scheduler.Worker w = scheduler.createWorker();

            source.subscribe(new ObserveOnObserver(observer, w, delayError, bufferSize));
        }
    }

这里的source就是之前步骤3.1保存的ObservableSubscribeOn对象，而observer就是最外层传入的观察者对象，由此可以看出观察者被内部类ObserveOnObserver进行了装饰。
w就是handler线程调度者创建的工作者主要用来将ObserveOnObserver(实现了runnable接口)通过handler发送到主线程上面去，从而实现线程调度
4.这个时候要调用source的subscribe了，跟ObservableObserveOn类似，之后进入到ObservableSubscribeOn的subscribeActual方法中：

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

        s.onSubscribe(parent);

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

这里的s就是步骤4.3new出来的ObserveOnObserver对象，这里将s装饰到SubscribeOnObserver对象中，然后调用ObserveOnObserver的onSubscribe方法 ↓↓↓

        @Override
        public void onSubscribe(Disposable s) {
                ...代码省略...
                actual.onSubscribe(this);
            }
        }

这里的actual其实就是最外层的观察者，然后就会调用最外层观察者的onSubscribe方法，此时由于并没有做任何的线程调度，所以当前的操作处于主线程中。因此log5出打出来的线程应该是主线程

好了，我们再回到subscribeActual方法中，此时调用scheduler.scheduleDirect方法,将SubscribeTask对象传入:

    @NonNull
    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;
    }

run就是传入SubscribeTask的对象，将SubscribeTask的对象装饰到DisposeTask中，
w是IO线程调度者创建的切换线程的实际工作者，此时调用createWorker就会执行IoScheduler的createWork方法new 出EventLoopWorker对象：

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

而w.schedule也就是执行了EventLoopWorker的schedule方法，将DisposeTask传入：

        @NonNull
        @Override
        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);
        }

接着调用threadWorker里面的scheduleActual方法：

   @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