rxJava和rxAndroid源码解析系列二之observer订阅

接着上一篇的demo继续写下去。没看过的朋友请点击 rxJava和rxAndroid源码解析系列一之链式调用Observable嵌套

创建完Observable对象后，以后一步ObservableObserveOn.subscribe(new Observer() {.....})这一步又发生了什么呢?

接着跟踪源码。

 @SchedulerSupport(SchedulerSupport.NONE)
    @Override
    public final void subscribe(Observer observer) {
        ObjectHelper.requireNonNull(observer, "observer is null");
        try {
            observer = RxJavaPlugins.onSubscribe(this, observer);

            ObjectHelper.requireNonNull(observer, "The RxJavaPlugins.onSubscribe hook returned a null Observer. Please change the handler provided to RxJavaPlugins.setOnObservableSubscribe for invalid null returns. Further reading: https://github.com/ReactiveX/RxJava/wiki/Plugins");
            //主要是这行代码，也是实际订阅执行的，接下来看看怎么做的
            subscribeActual(observer);
        } catch (NullPointerException e) { // NOPMD
            throw e;
        } catch (Throwable e) {
            Exceptions.throwIfFatal(e);
            // can't call onError because no way to know if a Disposable has been set or not
            // can't call onSubscribe because the call might have set a Subscription already
            RxJavaPlugins.onError(e);

            NullPointerException npe = new NullPointerException("Actually not, but can't throw other exceptions due to RS");
            npe.initCause(e);
            throw npe;
        }
    }

                                                                                             <源代码片段1>

 subscribeActual(observer);这个方法，是Observable的抽象方法，由子类实现，那是谁呢，ObservableObserveOn或AbstractObservableWithUpstream，经过查找在ObservableObserveOn找到了这个实现

    @Override
    protected void subscribeActual(Observer observer) {
//scheduler是HandlerScheduler的对象，而HandlerScheduler是Scheduler的子类
        if (scheduler instanceof TrampolineScheduler) {//这个就会跳过
            source.subscribe(observer);
        } else {
            //那就从这里开始执行
            Scheduler.Worker w = scheduler.createWorker();

            source.subscribe(new ObserveOnObserver(observer, w, delayError, bufferSize));
        }
    }

                                                                                      <源代码片段2>

通过上一篇的分析source指向的是ObservableSubscribeOn的对象，scheduler是HandlerScheduler的对象，所以实际执行的是下面两行代码

                          Scheduler.Worker w = scheduler.createWorker();

            source.subscribe(new ObserveOnObserver(observer, w, delayError, bufferSize));

先看第一行

   @Override
    public Worker createWorker() {
        return new HandlerWorker(handler, async);
    }

                                                                                <源代码片段3>

HandlerWorker是HandlerScheduler的静态内部类。HandlerWorker中也有ui线程的handler。

第二行代码先看new实例对象。ObserveOnObserver是ObservableObserveOn的静态内部类，ObserveOnObserver是对observer回调的装饰和扩展，就不贴出代码了。好的，source.subscribe(new ObserveOnObserver(observer, w, delayError, bufferSize));怎么执行的呢，这个source指向的是ObservableSubscribeOn的对象，ObservableSubscribeOn也是Observable对象的子类，所以subscribe方法和<源代码片段1>一样。那就看看它实际执行订阅的代码啦

    @Override
    public void subscribeActual(final Observer observer) {
        final SubscribeOnObserver parent = new SubscribeOnObserver(observer);

        observer.onSubscribe(parent);

        parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));
    }

                                                                                  <源代码片段4>

就三行代码，就把这个线程切换和回调都完成啦？脑子里突然蹦出一句歌词，没那么简单.....那就仔细分析一下吧，第一行代码就是把传过来的ObserveOnObserver对象继续封装一下下，转变成SubscribeOnObserver，而这个类就是ObservableSubscribeOn的内部类，也进行了装饰和扩展。也没什么东东嘛，那就继续第二句observer.onSubscribe(parent);observer是ObserveOnObserver它的实例对象，我们都知道啦ObserveOnObserver是ObservableObserveOn的静态内部类，那就进去看看这个方法啦！

        @Override
        public void onSubscribe(Disposable d) {
//此时d就是传入过来的ObserveOnObserver对象嘛
// this.upstream成员变量，找了一圈，构造的时候没有它的事，为null
            if (DisposableHelper.validate(this.upstream, d)) {//if判断返回true
                this.upstream = d;
                if (d instanceof QueueDisposable) {//if判断返回false
                    @SuppressWarnings("unchecked")
                    QueueDisposable qd = (QueueDisposable) d;

                    int m = qd.requestFusion(QueueDisposable.ANY | QueueDisposable.BOUNDARY);

                    if (m == QueueDisposable.SYNC) {
                        sourceMode = m;
                        queue = qd;
                        done = true;
                        downstream.onSubscribe(this);
                        schedule();
                        return;
                    }
                    if (m == QueueDisposable.ASYNC) {
                        sourceMode = m;
                        queue = qd;
                        downstream.onSubscribe(this);
                        return;
                    }
                }
                //队列
                queue = new SpscLinkedArrayQueue(bufferSize);
                //downstream就是Observer,也就是样例代码中的new Observer(String){},就是最终回调的嘛
                downstream.onSubscribe(this);
            }
        }

                                                                                   <源代码片段5>

那就先看看这个喽DisposableHelper.validate(this.upstream, d)

    public static boolean validate(Disposable current, Disposable next) {
        if (next == null) {//next=ObserveOnObserver的对象，不为null,跳过
            RxJavaPlugins.onError(new NullPointerException("next is null"));
            return false;
        }
        if (current != null) {//current=(this.upstream=null,跳过
            next.dispose();
            reportDisposableSet();
            return false;
        }
        return true;
    }

                                                                                        <源代码片段6>

返回true, <源代码片段5>继续往下执行d instanceof QueueDisposable，这个判断，d是ObservableSubscribeOn静态内部类ObserveOnObserver的对象，那就看看这个是什么类型的

  static final class SubscribeOnObserver extends AtomicReference implements Observer, Disposable {
...............................省略
}

                                                                                      <源代码片段7>

QueueDisposable又是啥呢

public interface QueueDisposable extends QueueFuseable, Disposable {
}

                                                                                      <源代码片段8>

d instanceof QueueDisposable就只能返回fase了，if代码块跳过。<源代码片段5>继续往下执行 downstream.onSubscribe(this);

这个downstream是个成员变量，什么时候赋值的呢？

        ObserveOnObserver(Observer actual, Scheduler.Worker worker, boolean delayError, int bufferSize) {
            this.downstream = actual;
            this.worker = worker;
            this.delayError = delayError;
            this.bufferSize = bufferSize;
        }

                                                                                     <源代码片段9>

构造的时候赋值的，谁调用了呢， <源代码片段2>中赋值的，传入过来的observer是谁呢？就是这句话嘛，ObservableObserveOn.subscribe(new Observer() {.....})，才调用了 <源代码片段2>的代码段，这个不是最终回调嘛，搜嘎，

               @Override
                            public void onSubscribe(Disposable d) {
 //当前线程不就是new Thread()嘛，原来如此                               

Log.i("MainActivity","onSubscribe"+Thread.currentThread().getId()+":"+Thread.currentThread().getName());
                            }

<源代码片段4>中的 observer.onSubscribe(parent);结束了，那就继续看<源代码片段4>的最后一句代码parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));这句代码肯定会开辟一片新天地，它要肩负着线程切换和回调嘛。这句话嵌套的有点多，那我们就把他继续分解，先看看new SubscribeTask(parent)，这个类也是ObservableSubscribeOn它的内部类

final class SubscribeTask implements Runnable {
        private final SubscribeOnObserver parent;

        SubscribeTask(SubscribeOnObserver parent) {
            this.parent = parent;
        }

        @Override
        public void run() {
//ObservableSubscribeOn的source,这个source指向ObservableCreate
            source.subscribe(parent);
        }
    }

                                                                              <源代码片段10>

这个就是封装了一下,没什么东东，接着这句scheduler.scheduleDirect(new SubscribeTask(parent)))；我们知道这个scheduler是ObservableSubscribeOn的成员变量，通过上一篇的介绍，这个scheduler是NewThreadScheduler的对象

    @NonNull
    public Disposable scheduleDirect(@NonNull Runnable run) {
//run就是SubscribeTask 的对象嘛
        return scheduleDirect(run, 0L, TimeUnit.NANOSECONDS);
    }

                                                                              <源代码片段11>

返回个disposable，还要继续跟进

    @NonNull
    public Disposable scheduleDirect(@NonNull Runnable run, long delay, @NonNull TimeUnit unit) {
        final Worker w = createWorker();//NewThreadScheduler的createWorker()方法创建NewThreadWorker对象

        final Runnable decoratedRun = RxJavaPlugins.onSchedule(run);//decoratedRun =run

        DisposeTask task = new DisposeTask(decoratedRun, w);

        w.schedule(task, delay, unit);

        return task;
    }

                                                                                      <源代码片段12>

DisposeTask这个类是什么呢

static final class DisposeTask implements Disposable, Runnable, SchedulerRunnableIntrospection {

.........................省略

   DisposeTask(@NonNull Runnable decoratedRun, @NonNull Worker w) {
            this.decoratedRun = decoratedRun;
            this.w = w;
        }

        @Override
        public void run() {
            runner = Thread.currentThread();
            try {
                decoratedRun.run();//decoratedRun是SubscribeTask的对象，是ObservableSubscribeOn的内部类
            } finally {
                dispose();
                runner = null;
            }
        }
......................省略
}

                                                                               <源代码片段13>

构建完之后，并没有直接返回，而是执行这段代码 w.schedule(task, delay, unit);w是NewThreadWorker的对象，那就跟踪这段代码吧

    @NonNull
    @Override
    public Disposable schedule(@NonNull final Runnable action, long delayTime, @NonNull TimeUnit unit) {
    /**
    *根据源码片段11、12、13得知一下
    *runnable是DisposeTask 它的run方法是调用SubscribeTask的run方法
    *delayTime=0L
    *unit为TimeUnit.NANOSECONDS
    */
        if (disposed) {//跳过
            return EmptyDisposable.INSTANCE;
        }
        return scheduleActual(action, delayTime, unit, null);
    }

                                                                    <源代码片段14>

那就是要继续scheduleActual方法

    @NonNull
    public ScheduledRunnable scheduleActual(final Runnable run, long delayTime, @NonNull TimeUnit unit, @Nullable DisposableContainer parent) {
        Runnable decoratedRun = RxJavaPlugins.onSchedule(run);//decoratedRun =run

        ScheduledRunnable sr = new ScheduledRunnable(decoratedRun, parent);

        if (parent != null) {//parent为null,跳过
            if (!parent.add(sr)) {
                return sr;
            }
        }

        Future f;
        try {
            if (delayTime <= 0) {//delayTime 此时为0
                f = executor.submit((Callable