接着上一篇文章<<rxJava和rxAndroid源码解析系列二之observer订阅>>继续说一下线程切换。在上一篇的 <源代码片段15>中可以看出订阅事件以及扔到线程池中进行执行，也就是要订阅的东西已经切换线程了。上篇文章讲到 <源代码片段19>中的代码片段source.subscribe(parent)；也就是执行这句话，根据上一篇的关系引用图我们知道source是ObservableOnSubscribe，subscribe是ObservableOnSubscribe的方法，是我们在代码中定义的，代码也就是第一篇文章的下面的代码
Observable.create(new ObservableOnSubscribe<String>() {//create创建产生的实例类型ObservableCreate<T>
@Override
public void subscribe(ObservableEmitter<String> emitter) throws Exception {
Log.i("MainActivity",Thread.currentThread().getId()+":"+Thread.currentThread().getName());
emitter.onNext("hello");
emitter.onNext("world");
emitter.onComplete();
}
})subscribe方法不是我们的调度计划嘛，原来如此。parent也就是subscribe方法的参数ObservableEmitter<String> emitter,也就是ObservableCreate的静态内部类CreateEmitter的对象。也就可以这么说我们的计划调度是通过ObservableEmitter进行往下游回调的。
那就看看计划调度onNext,也就是ObservableEmitter.onNext方法。
@Override
public void onNext(T t) {
if (t == null) {
onError(new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources."));
return;
}
if (!isDisposed()) {//是否可用
observer.onNext(t);//这个observer是ObservableSubscribeOn.SubscribeOnObserver的对象
}
}<源代码片段1>
看来又往下游的观察者进行回调，ObservableSubscribeOn.SubscribeOnObserver.onNext(T t)
@Override
public void onNext(T t) {
//没做什么处理，只是直接进行往下游回调了，downstream我们知道它是上一篇文章<源代码4>中初始化的，就是ObservableObserveOn的静态内部类ObserveOnObserver的对象
downstream.onNext(t);
}<源代码片段2>
没做什么操作，继续往下游回调
@Override
public void onNext(T t) {
if (done) {//有没有完成
return;
}
if (sourceMode != QueueDisposable.ASYNC) {//sourceMode =0,QueueDisposable.ASYNC=2
queue.offer(t);
}
schedule();
}<源代码片段3>
queue是一个队列，t加入这个队列。然后看看schedule();
void schedule() {
if (getAndIncrement() == 0) {//ObserveOnObserver的原子值，默认为0
//getAndIncrement()我们知道先取值后自增
worker.schedule(this);
}
}<源代码片段4>
这个worker是谁呢，看过前面两章的朋友知道，这个worker是HandlerWorker的对象，这个worker拥有成员变量handler，这个handler是主线程的。这个this就是ObservableSubscribeOn.SubscribeOnObserver，它也实现了runnable，
@Override
public void run() {
if (outputFused) {//outputFused拒绝输出标志位，默认情况为false
drainFused();
} else {
drainNormal();
}
}<源代码片段5>
那我们看看worker.schedule(this);这个方法喽！
@NonNull
public Disposable schedule(@NonNull Runnable run) {
return schedule(run, 0L, TimeUnit.NANOSECONDS);
}<源代码片段6>
什么鬼，还要跟踪。
@Override
@SuppressLint("NewApi") // Async will only be true when the API is available to call.
public Disposable schedule(Runnable run, long delay, TimeUnit unit) {
if (run == null) throw new NullPointerException("run == null");
if (unit == null) throw new NullPointerException("unit == null");
if (disposed) {//这时为false,跳过
return Disposables.disposed();
}
run = RxJavaPlugins.onSchedule(run);//还是run，没啥变化
//ScheduledRunnable也是个runnable,run方法还是调用传过来的run方法，这里不贴出来了
ScheduledRunnable scheduled = new ScheduledRunnable(handler, run);
Message message = Message.obtain(handler, scheduled);//创建一个主线程的message
message.obj = this; // Used as token for batch disposal of this worker's runnables.
if (async) {//这里为false,跳过
message.setAsynchronous(true);
}
//传过来的delay为0，也就是立即发送
handler.sendMessageDelayed(message, unit.toMillis(delay));
// Re-check disposed state for removing in case we were racing a call to dispose().
if (disposed) {
handler.removeCallbacks(scheduled);
return Disposables.disposed();
}
return scheduled;
}<源代码片段7>
我们来主要看这句话 Message message = Message.obtain(handler, scheduled);handler是主线程的，这种创建message不就是发送给主线程处理的嘛？看来这里已经切换到主线程了！！！(不了解handler、Looper的机制的可以去了解一下)。我这里说一下handler里面有一个处理消息的方法
/**
* Handle system messages here.
*/
public void dispatchMessage(Message msg) {
if (msg.callback != null) {//如果message中的callback不为null,处理这个callable
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);//这个是我们平时处理消息的方法
}
}<源代码片段8>
private static void handleCallback(Message message) {
message.callback.run();
}<源代码片段9>
到这里我们知道了,message.callback就是ScheduledRunnable ，这个ScheduledRunnable是对ObservableObserveOn.ObserveOnObserver的封装，实际执行的也就是这个run方法，也就是 <源代码片段5>中的代码。那我门就看看这里面怎么执行的。
outputFused默认情况为false,只有再执行requestFusion的时候且满足特定条件才为true.
@Override
public int requestFusion(int mode) {
if ((mode & ASYNC) != 0) {
outputFused = true;
return ASYNC;
}
return NONE;
}<源代码片段10>
那我们就看看这个drainNormal();
void drainNormal() {
int missed = 1;
final SimpleQueue<T> q = queue;//调度返回的数据队列
final Observer<? super T> a = downstream;
for (;;) {
if (checkTerminated(done, q.isEmpty(), a)) {//检查是否到终点，如果到了终点
//跳出循环，没有的话，跳过这个if
return;
}
for (;;) {
boolean d = done;
T v;
try {
v = q.poll();//取队列数据
} catch (Throwable ex) {
//发生异常，队列清空，上游调度和下游回调结束
Exceptions.throwIfFatal(ex);
disposed = true;
upstream.dispose();
q.clear();
a.onError(ex);
worker.dispose();
return;
}
boolean empty = v == null;
if (checkTerminated(d, empty, a)) {
return;
}
if (empty) {//如果队列空了，没有检测到终点，跳出这个for循环，这样的话，让子线程重新回调再切换一次线程
break;
}
a.onNext(v);//数据最终回调
}
missed = addAndGet(-missed);//missed =0
if (missed == 0) {//中断for循环
break;
}
}
}<源代码片段11>
好，到这里已经说完了onNext的回调过程，以及子线程如何切换到主线程的。有兴趣的同学可以看看CreateEmitter.onError和CreateEmitter.onComplete过程。