RxJava线程切换原理

这篇文章跟上一篇的RxJava执行流程有关联性，没阅读上一篇的先瞅一下。

怎么进行线程切换的

subscribeOn(Schedulers.io())

首先了解下Scheduler.io()方法，它返回的是一个Scheduler，Scheduler是一个抽象方法，我们知道抽象方法是不能被实例化的，那么返回的肯定是它的实现类：

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

上面代码里的IO对象是什么呢？

  IO = RxJavaPlugins.initIoScheduler(new Callable() {
        @Override
        public Scheduler call() throws Exception {
            return IoHolder.DEFAULT;
        }
    });

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

答案是IoScheduler对象。

在前面的学习中，我们知道了subscribeOn(Schedulers.io())返回的对象是ObservableSubscribeOb对象

    public ObservableSubscribeOn(ObservableSource source, Scheduler scheduler) {
        super(source);
        this.scheduler = scheduler;
    }

    @Override
    public void subscribeActual(final Observersuper T> s) {
        final SubscribeOnObserver parent = new SubscribeOnObserver(s);

        s.onSubscribe(parent);

        parent.setDisposable(scheduler.scheduleDirect(new Runnable() {
            @Override
            public void run() {
                source.subscribe(parent);
            }
        }));
    }

source.subscribe(parent) 被放在一个Runnable中执行，那么他是否已经就在子线程执行了呢？

NO，NO，NO,这还得看Runnable是被放在哪个线程上的，说不定是mainThread呢。

先看看scheduleDirect方法

  //无延迟执行
  public Disposable scheduleDirect(Runnable run) {
        return scheduleDirect(run, 0L, TimeUnit.NANOSECONDS);
    }

scheduleDirect.java

 public Disposable scheduleDirect(Runnable run, long delay, TimeUnit unit) {
        //createWorker是一个抽象方法，创建一个可以可以执行 run 的 worker 
        final Worker w = createWorker();
        //对 run 进行了包装，实际上还是 run 这个对象
        final Runnable decoratedRun = RxJavaPlugins.onSchedule(run);
        //decoratedRun 交给了 worker 去执行
        w.schedule(new Runnable() {
            @Override
            public void run() {
                try {
                    decoratedRun.run();
                } finally {
                    w.dispose();
                }
            }
        }, delay, unit);

        return w;
    }

直指IoScheduler#createWorker()

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

EventLoopWorker.java

 static final class EventLoopWorker extends Scheduler.Worker {
        //省略部分code

        @Override
        public Disposable schedule(Runnable action, long delayTime, TimeUnit unit) {
            if (tasks.isDisposed()) {
                // don't schedule, we are unsubscribed
                return EmptyDisposable.INSTANCE;
            }

            return threadWorker.scheduleActual(action, delayTime, unit, tasks);
        }
    }

EventLoopWorker extends Scheduler.Worker ，Worker这个抽象类有个schedule()抽象方法需要重写，所以这个类的核心逻辑就在schedule()方法里：==threadWorker.scheduleActual(action, delayTime, unit, tasks);== ，点击进去看看：

public class NewThreadWorker extends Scheduler.Worker implements Disposable {
    //executor  是一个线程池
    private final ScheduledExecutorService executor;

    volatile boolean disposed;

    public NewThreadWorker(ThreadFactory threadFactory) {
        executor = SchedulerPoolFactory.create(threadFactory);
    }

    //省略部分代码

    public ScheduledRunnable scheduleActual(final Runnable run, long delayTime, TimeUnit unit, DisposableContainer parent) {
            //对传进来的run进行包装
            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