Rxjava中subscribeOn(Schedulers.io())-＞源码分析

 

// TODO hook 给 IO 初始化

RxJavaPlugins.setInitIoSchedulerHandler(new Function<Callable<Scheduler>, Scheduler>() {
    @Override
    public Scheduler apply(Callable<Scheduler> schedulerCallable) throws Exception {
        Log.d(L.TAG, "apply: 全局 监听 init scheduler：" +schedulerCallable.call());
        return schedulerCallable.call();
    }
});
Observable.create(
        // 自定义source
        new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> e) throws Exception {
                e.onNext("xxxxx");
                Log.d(L.TAG, "自定义source: " + Thread.currentThread().getName());
            }
})
// ObservbaleCreate.subscribeOn
// TODO 第二步     new IOScheduler ---> 线程池 传递进去
.subscribeOn(
        // TODO 第一步  到底干了什么 （ new IOScheduler ---> 线程池）
        Schedulers.io() // 耗时读取的异步
        // Schedulers.newThread() // 开启新线程
)
 // A线程. subscribe
 //  ObservableSubscribeOn.subscribe
.subscribe(

        // 终点
        new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {

                Disposable disposable = d;
                Log.d(L.TAG, "onSubscribe: " +  Thread.currentThread().getName());
            }

            @Override
            public void onNext(String s) {
                Log.d(L.TAG, "onNext: " + Thread.currentThread().getName());
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
});

当我们点击subscribeOn(Scheduler.io),此时处于异步线程中

此时我们看到源码 

RxJavaPlugins.onAssembly(new ObservableSubscribeOn<T>(this, scheduler));这个当中的

ObservableSubscribeOn的源码如下

public final class ObservableSubscribeOn<T> extends AbstractObservableWithUpstream<T,T> {
    final Scheduler scheduler;
    public ObservableSubscribeOn(ObservableSource<T> source, Scheduler scheduler) {
        super(source);
        this.scheduler = scheduler;
    }
    @Override
    public void subscribeActual(final Observer<? super T> s) {
        final SubscribeOnObserver<T> parent = new SubscribeOnObserver<T>(s);
        s.onSubscribe(parent);
        parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));
    }

  在ObservableSubscribeOn中subscribeActual方法中，创建了SubscribeOnObserver关联操作        Observer对象类,s.onSubscribe()当前线程中调用Observer,其中构建的SubscribeOnObserver引用类parent,调用了scheduler.scheduleDirect（new SubcribeTask），scheduler等价于刚开始Schedulers.io()

我们在看scheduler.scheduleDirect方法

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

 

ScheduleDirect的源码

 * This method is safe to be called from multiple threads but there are no
 * ordering guarantees between tasks.
 *
 * @param run the task to schedule
 * @param delay the delay amount, non-positive values indicate non-delayed scheduling
 * @param unit the unit of measure of the delay amount
 * @return the Disposable that let's one cancel this particular delayed task.
 * @since 2.0
 */
@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;
}

此方法 在scheduleDirect中   createWorker()创建一个worker

此时我们看

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

这是Sschedule.io()的流程图

 

这其中Schedule的其他类分析

Schedulers.computation()

计算工作默认的调度器，这个计算指的是 CPU 密集型计算，即不会被 I/O 等操作限制性能的操作，例如图形的计算。这个 Scheduler 使用的固定的线程池，大小为 CPU 核数。

Schedulers.immediate()

这个调度器允许你立即在当前线程执行你指定的工作。这是默认的Scheduler。

Schedulers.newThread()

这个调度器正如它所看起来的那样：它为指定任务启动一个新的线程。

Schedulers.trampoline()

当我们想在当前线程执行一个任务时，并不是立即，我们可以用trampoline() 将它入队。这个调度器将会处理它的队列并且按序运行队列中每一个任务。