RxJava系列(三)--切换线程

1.主线程是怎么切换到子线程
2.为什么只有第一次切换有效
3.子线程是怎么切换到主线程
1>问题1,主线程是怎么切换到子线程,实际上先不看源码,换做我们自己写的话,最简单的用Thread和Runnable就可以实现
那么从这行代码分析:

.subscribeOn(Schedulers.io())

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

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 observer) {
        final SubscribeOnObserver parent = new SubscribeOnObserver(observer);

        observer.onSubscribe(parent);

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

 final class SubscribeTask implements Runnable {
        private final SubscribeOnObserver parent;

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

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

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

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

so,接下来看Schedulers的具体实现了.

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

缕缕头绪,实际就是一段代码:

createWorker().schedule(new Runnable() {
            @Override
            public void run() {
                source.subscribe(parent);
            }
        },0,TimeUnit.NANOSECONDS)
createWorker()-->Schedulers.io()
source-->ObservableCreate

那么接下来看一下Schedulers.io()的实现吧.

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

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

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

 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);
        }
    }

 public ScheduledRunnable scheduleActual(final Runnable run, long delayTime, @NonNull TimeUnit unit, @Nullable DisposableContainer parent) {
     ... ScheduledRunnable sr = new ScheduledRunnable(decoratedRun, parent);
        try {
            if (delayTime <= 0) {
                f = executor.submit((Callable