首先看下我们RxJava的常规使用方法

代码A 调用类

Observable.create(new ObservableOnSubscribe<String>() {
    @Override
    public void subscribe(ObservableEmitter<String> e) throws Exception {
        e.onNext(XXX);
        e.onComplete();
    }
}).subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread()).subscribe(new Observer<String>() {
    @Override
    public void onSubscribe(Disposable d) {
    }

    @Override
    public void onNext(String s) {
        Log.e("tag", s);
    }

    @Override
    public void onError(Throwable e) {
    }

    @Override
    public void onComplete() {
    }

});

1、Schedulers.io()为IoScheduler

下面看下subscribeOn(Schedulers.io())这个方法，把代码贴出来

代码B ObservableCreate类

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

最后真正执行的是ObservableSubscribeOn类中的subscribeActual方法

代码C ObservableSubscribeOn类

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

形参 s 为观察者，在外层执行Observable.subscribe（Observer）之后，观察者的onSubscribe()方法是首先会被调用的，调用位置便在 代码C 中的s.onSubscribe(parent)。

重点来看一下 代码C 中的最后一行代码。首先看下SubscribeTask类。

代码D ObservableSubscribeOn类

final class SubscribeTask implements Runnable {
    private final SubscribeOnObserver<T> parent;

    SubscribeTask(SubscribeOnObserver<T> parent) {
        this.parent = parent;
    }

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

实际上SubscribeTask就是一个Runnable类，在其run方法中，执行了source.subscribe(parent);其中source就是我们 代码B 中new ObservableSubscribeOn<T>(this, scheduler)传入的this，在这里也就是ObservableCreate类，parent就是 代码C 中s的包装类，在这里可以看成是观察者类。

接着看下 代码C 中的 scheduler.scheduleDirect(new SubscribeTask(parent))

//scheduleDirect源码如下

代码E Scheduler类（IoScheduler）

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

createWorker() 方法是一个抽象方法，IoScheduler类的具体实现如下，new了一个 EventLoopWorker
public Worker createWorker() {
    return new EventLoopWorker(pool.get());
}

pool.get()是从线程池CachedWorkerPool中取一个线程NewThreadWorker

重点是在 代码E中的w.schedule(task, delay, unit)，即eventLoopWorker.schedule方法，一直跟下去，到最终调用处如下

代码F NewThreadWorker类

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<Object>)sr);
        } else {
            f = executor.schedule((Callable<Object>)sr, delayTime, unit);
        }
        sr.setFuture(f);
    } catch (RejectedExecutionException ex) {
        if (parent != null) {
            parent.remove(sr);
        }
        RxJavaPlugins.onError(ex);
    }

    return sr;
}

因为我们也没有设置delay时间，所以我们重点看下executor.submit((Callable<Object>)sr);

经过层层传递，其中传入的参数sr即为 代码C 中的SubscribeTask。此时此刻，基本上都清晰了，在这里执行submit放法，实际上就是执行我们 代码D 中的source.subscribe(parent);由于此处是在子线程中调用，所以能满足在最外层调用
subscribeOn(Schedulers.io())之前的上游代码都运行在子线程中。

说到上游，我们回到代码A。ObservableSubscribeOn的上游便是我们通过方法Observable.create()创建的ObservableCreate类。

代码D 中的source.subscribe(parent)便相当于直接调到了ObservableCreate类的subscribe()方法。相同的套路，最终都会调到ObservableCreate类的subscribeActual()方法。

代码G ObservableCreate类

@Override

protected void subscribeActual(Observer<? super T> observer) {

    CreateEmitter<T> parent = new CreateEmitter<T>(observer);
    observer.onSubscribe(parent);
    try {
        source.subscribe(parent);
    } catch (Throwable ex) {
        Exceptions.throwIfFatal(ex);
        parent.onError(ex);
    }
}

source.subscribe(parent)中的source即为 代码A 中Observable.create(new ObservableOnSubscribe<String>())方法传入的ObservableOnSubscribe类。调用source.subscribe()方法，即调用 ObservableOnSubscribe 类中的 subscribe() 方法。

ObservableOnSubscribe为一个接口，代码如下：

public interface ObservableOnSubscribe<T> {

    /**
    * Called for each Observer that subscribes.
    * @param e the safe emitter instance, never null
    * @throws Exception on error
    */
    void subscribe(@NonNull ObservableEmitter<T> e) throws Exception;

}

这下便回到了我们熟悉的外部调用。其中形参 e 便为 代码G 中第9行传入的parent，即observer的包装类。

e.onNext(XXX)方法的分析请看下一篇文章RxJava线程切换之observeOn源码分析