rxJava和rxAndroid源码解析系列三之线程切换

接着上一篇文章<>继续说一下线程切换。在上一篇的 <源代码片段15>中可以看出订阅事件以及扔到线程池中进行执行，也就是要订阅的东西已经切换线程了。上篇文章讲到 <源代码片段19>中的代码片段source.subscribe(parent)；也就是执行这句话，根据上一篇的关系引用图我们知道source是ObservableOnSubscribe，subscribe是ObservableOnSubscribe的方法，是我们在代码中定义的，代码也就是第一篇文章的下面的代码

 Observable.create(new ObservableOnSubscribe() {//create创建产生的实例类型ObservableCreate
                    @Override
                    public void subscribe(ObservableEmitter emitter) throws Exception {
                        Log.i("MainActivity",Thread.currentThread().getId()+":"+Thread.currentThread().getName());
                        emitter.onNext("hello");
                        emitter.onNext("world");
                        emitter.onComplete();
                    }
                })

subscribe方法不是我们的调度计划嘛，原来如此。parent也就是subscribe方法的参数ObservableEmitter 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 q = queue;//调度返回的数据队列
            final Observer 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过程。