RxJava源码分析之subscribeOn和observeOn

RxJava源码分析之subscribeOn和observeOn

RxJava的特色就是可以改变他的任务线程，可以很优雅的在子线程和主线程中切换，而切换用到的两个主要方法是subscribeOn()和observeOn().

备注：因本人水平有限，以下分析只代表本人所见，如有不当，请见谅并指出。

subscribeOn()和observeOn()的区别

• subscribeOn()主要改变的是订阅的线程。即call()执行的线程
• ObserveOn()主要改变的是发送的线程。即onNext()执行的线程。

subscribeOn()分析

在分析之前，首先要明确一点，不然会产生思路混乱。

当我们调用了Observable.subscribe()方法，发生了什么？？？？

总结性的说：创建Subscriber对象，调用OnSubscribe对象的call方法。注意，Subscriber什么都没做，Subscriber什么都没做，Subscriber什么都没做。重要的事情说三遍，下面开始分析。

首先，我们写一个例子：

 Observable
                .create(new Observable.OnSubscribe<String>() {
                    @Override
                    public void call(Subscriber<? super String> subscriber) {
                        subscriber.onNext("a");
                        subscriber.onNext("b");

                        subscriber.onCompleted();
                    }
                })
                .subscribeOn(Schedulers.io())

                .subscribe(new Observer<String>() {
                    @Override
                    public void onCompleted() {

                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onNext(String integer) {
                        System.out.println(integer);
                    }
                });

这个例子很简单，但在intellij 中运行，不打印任何东西，但在ecplise中确没问题。打印如下：

a
b

这个问题我也搞不清为什么，如果有知道的欢迎留言。

老套路，我们看一下subscribeOn()中，都干了什么

  public final Observable<T> subscribeOn(Scheduler scheduler) {
        if (this instanceof ScalarSynchronousObservable) {
            return ((ScalarSynchronousObservable<T>)this).scalarScheduleOn(scheduler);
        }
        return create(new OperatorSubscribeOn<T>(this, scheduler));
    }

很明显，会走if之外的方法。

在这里我们可以看到，我们又创建了一个Observable对象，但创建时传入的参数为OperatorSubscribeOn(this,scheduler)，我们看一下此对象以及其对应的构造方法

public final class OperatorSubscribeOn<T> implements OnSubscribe<T> {

    final Scheduler scheduler;
    final Observable<T> source;

    public OperatorSubscribeOn(Observable<T> source, Scheduler scheduler) {
        this.scheduler = scheduler;
        this.source = source;
    }

    @Override
    public void call(final Subscriber<? super T> subscriber) {
        //......暂时省略
    }
}

可以看到，OperatorSubscribeOn实现