首先看下我们RxJava的常规使用方法
代码A 调用类
Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(ObservableEmitter e) throws Exception {
e.onNext(XXX);
e.onComplete();
}
}).subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread()).subscribe(new Observer() {
@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 subscribeOn(Scheduler scheduler) {
ObjectHelper.requireNonNull(scheduler, "scheduler is null");
return RxJavaPlugins.onAssembly(new ObservableSubscribeOn(this, scheduler));
}
最后真正执行的是ObservableSubscribeOn类中的subscribeActual方法
代码C ObservableSubscribeOn类
@Override
public void subscribeActual(final Observer s) {
final SubscribeOnObserver parent = new SubscribeOnObserver(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 parent;
SubscribeTask(SubscribeOnObserver parent) {
this.parent = parent;
}
@Override
public void run() {
source.subscribe(parent);
}
}
实际上SubscribeTask就是一个Runnable类，在其run方法中，执行了source.subscribe(parent);其中source就是我们 代码B 中new ObservableSubscribeOn
接着看下 代码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因为我们也没有设置delay时间，所以我们重点看下executor.submit((Callable
经过层层传递，其中传入的参数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 observer) {
CreateEmitter parent = new CreateEmitter(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
ObservableOnSubscribe为一个接口，代码如下：
public interface ObservableOnSubscribe {
/**
* Called for each Observer that subscribes.
* @param e the safe emitter instance, never null
* @throws Exception on error
*/
void subscribe(@NonNull ObservableEmitter e) throws Exception;
}
这下便回到了我们熟悉的外部调用。其中形参 e 便为 代码G 中第9行传入的parent，即observer的包装类。
e.onNext(XXX)方法的分析请看下一篇文章RxJava线程切换之observeOn源码分析