【拆轮子系列】RxJava2 源码简要分析

RxJava1 已经在项目中用来一年多了，最近准备转换成 RxJava2， 除了去了解 2.0版本的不同 ，还简单的去了解了一下源码，顺便做个记录。

对源码的分析，要明确目的：
1. 数据是怎样从数据源到订阅者的；
2. 线程切换时怎样实现的；

一、 数据源的发射到订阅

        Observable<Integer> observable = Observable.create(
                        new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) 
                                    throws Exception {
                e.onNext(1);
                e.onComplete();
            }
        });

        Observer observer = new Observer() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.e(TAG, "onSubscribe " + d.isDisposed());
            }

            @Override
            public void onNext(Object value) {
                Log.e(TAG, "onNext " + value.toString());
            }

            @Override
            public void onError(Throwable e) {
                Log.e(TAG, "onError " + e.getMessage());
            }

            @Override
            public void onComplete() {
                Log.e(TAG, "onComplete ");
            }
        };

        observable.subscribe(observer);

上面的例子没有使用链式调用方式更能清楚的看到它们的联系
第一步：创建 observable

Observable<Integer> observable = Observable.create(....)

第二步：创建 observer

Observer observer = new Observer() 

第三步：将 observable 与 observer 联系起来

observable.subscribe(observer);

第一步，创建 observable

Observable#create(…) io.reactivex.Observable.java ,

public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
        ObjectHelper.requireNonNull(source, "source is null");
        return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));
    }

上面的 create(…) 方法返回的是一个 observable 对象，其实最终返回的是 ObservableCreate.
RxJavaPlugins.onAssembly 只是相当于 hook 而已

   public static <T> Observable<T> onAssembly(Observable<T> source) {
        Function<Observable, Observable> f = onObservableAssembly;
        if (f != null) {
            return apply(f, source);
        }
        return source;
    }

ObservableCreate<T> extends Observable<T> ;

public abstract class Observable<T> implements ObservableSource<T>

public interface ObservableSource<T> {
    void subscribe(Observer<? super T> observer);
}

从它们的关系可以看到， ObservableCreate 是继承 Observable

第二步， 创建 observer

这步没什么好讲的，仅仅只是创建 observer 而已

第三步,将 observable 与 observer 联系起来

 observable.subscribe(observer);

subscribe(…) 方法是重写 ObservableSource的

Observable#subscribe(…) io.reactivex.Observable.java

   @Override
    public final void subscribe(Observer<? super T> observer) {
        ObjectHelper.requireNonNull(observer, "observer is null");
        try {
            observer = RxJavaPlugins.onSubscribe(this, observer);

            ObjectHelper.requireNonNull(observer, "Plugin returned null
                                     Observer");

            subscribeActual(observer);
        } catch (NullPointerException e) { // NOPMD
            throw e;
        } catch (Throwable e) {
          ....
        }
    }

再调用 subscribeActual（…）,该方法是个抽象方法，有实现类去实现

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

在这里，实现类是第一步中创建的 ObservableCreate

   // io.reactivex.internal.operators.observable.ObservableCreate.java

    public ObservableCreate(ObservableOnSubscribe<T> source) {
        this.source = source;
    }

    @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 是 Observable<Integer> observable = Observable.create(new ObservableOnSubscribe<Integer>() 中的 ObservableOnSubscribe

CreateEmitter 是 ObservableEmitter 的实现类

class CreateEmitter<T>
    extends AtomicReference<Disposable>
    implements ObservableEmitter<T>, Disposable

所以，这里发送了数据，

      Observable<Integer> observable = Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) 
                                            throws Exception {
                // 发送数据， e 是 CreateEmitter
                e.onNext(1);
                e.onComplete();
            }
        });

然后将数据发射到 CreateEmitrer 中

io.reactivex.internal.operators.observable.ObservableCreate$CreateEmitter.java

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

如果没有被 disposed ，则会调用 observer.onNext(t) 方法，observer 是最终的订阅者，将数据传个订阅者。这里将observable 与 observer 联系起来。

// 最终的 observer 
   Observer observer = new Observer() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.e(TAG, "onSubscribe " + d.isDisposed());
            }

            // observer.onNext(t) 
            @Override
            public void onNext(Object value) {
                Log.e(TAG, "onNext " + value.toString());
            }

            @Override
            public void onError(Throwable e) {
                Log.e(TAG, "onError " + e.getMessage());
            }

            @Override
            public void onComplete() {
                Log.e(TAG, "onComplete ");
            }
        };

下面我们看一下第二个问题，RxJava 是怎样完成。

二、RxJava2 线程的切换

我们用一个链式结构调用例子看线程是怎样切换的
. 例子

        Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) 
                                            throws Exception {
                e.onNext(1);
                e.onComplete();
            }
        }).subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.i("yxh", " onSubscribe : " + 
                            Thread.currentThread().getName() );

            }

            @Override
            public void onNext(Integer value) {
                Log.i("yxh", "终点 Observer onNext" + value);
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });

这里将数据的发射放在 IO 线程中，定义线程是主线程

总图
Observable.create(..) <-- ObservableCreate
.subscribeOn(IoScheduler) <-- ObservableSubscribeOn
.observeOn(AndroidSchedulers.mainThread())  <-- ObservableObserveOn
.subscribe(new Observer)  <-- 调用抽象方法 Observale.subscribeActual(), 由实现类实现

. observable.create(…)   返回的是 ObservableCreate
. subscribeOn(…)   返回是 ObservableSubscribeOn
. observeOn(…)   返回是 ObservableObserveOn

ObservableCreate， ObservableSubscribeOn, ObservableObserveOn 都是 Observable 对象

由于
ObservableSubscribeOn extends AbstractObservableWithUpstream 

ObservableObserveOn<T> extends AbstractObservableWithUpstream

AbstractObservableWithUpstream extends Observable implements HasUpstreamObservableSource

ObservableSubscribeOn 和  ObservableObserveOn 都 extends Observable, 所以它们都是 Observale 对象，
所以，都会调用它们的 subscribeActual() 方法
ObservableSubscribeOn#subscribeActual()
ObservableObserveOn#subscribeActual()


Observable implements ObservableSource

public interface ObservableSource<T> {

    void subscribe(Observer<? super T> observer);
}

基于整个调用过程，我做了一张它们之间的关系图

. ObservableCreate 中的
  source 是数据源
  observer 是 ObservableSubscribleOn$SubscriOnObserver.java

. ObservableSubscribleOn 中的
  source 是 Observable
  observer 是 ObservableObserveOn 中的 ObservableObserveOn的ObserveOnObserver.java

. ObservableObserveOn 中的
  source 是 ObservableSubscribleOn
  observer 是最终的订阅者

数据传递的过程是
数据源 –>
ObservableCreate&CreateEmitter#onNext(…) –>
ObservableSubscribeOn&SubscribeOnObserver#onNext(…) –>
ObservableObserveOn&ObserveOnObserver#OnNext(…) –>
最终订阅者 Observer#onNext(..)

基于源码的分析的总流程

总的流程图(箭头向下)
Observable#subscrible(终点 Observer)

Observable#subscribeActual(终点 Observer) 抽象方法，由实现类 ObservableObserveOn 实现

ObservableObserveOn#subscribeActual(终点 Observer)

Scheduler#createWorker()  抽象方法，由实现类 HandlerScheduler 实现

HandlerScheduler#createWorker() 返回 HandlerWorker

// AObserveOnObserver = new ObserveOnObserver(终点 Observe, HandlerWorker, delayError, bufferSize);
ObservableSource#subscribe(AObserveOnObserver) 接口方法， 由实现类 ObservableSubscribeOn 实现, 


ObservableSubscribeOn#subscribe(AObserveOnObserver);
Observable#subscrible(AObserveOnObserver);    因为 ObservableSubscribeOn extands Observable, 所以调用的是 
                                                    Observable#subscrible();
Observable#subscribeActual(AObserveOnObserver);

ObservableSubscribeOn#subscribeActual(AObserveOnObserver);

AObserveOnObserver#onSubscribe(new SubscribeOnObserver(AObserveOnObserver))； @1 

ObserveOnObserver#onSubscribe(new SubscribeOnObserver(AObserveOnObserver));   ObservableObserveOn$ObserveOnObserver.java


@2 
Scheduler#scheduleDirect(new SubscribeTask(SubscribeOnObserver))

Scheduler#scheduleDirect(new SubscribeTask(SubscribeOnObserver), 0L, TimeUnit.NANOSECONDS)  重载函数

Worker w = createWorker(); 抽象方法，由实现类实现 这里是 IoScheduler

IoScheduler#createWorker();  返回 EventLoopWorker

Worker.schedule(...) [执行的是  EventLoopWorker#schedule()]

threadWorker.scheduleActual(action, delayTime, unit, tasks); [执行的是 NewThreadWorker#scheduleActual(...)}

ScheduledExecutorService#submit(...)  线程池执行，在新线程 第一次线程切换


******* 以下内容在新线程中执行 ******
ScheduledRunnable#run()    

actual.run();  io.reactivex.internal.operators.observable.ObservableSubscribeOn.java
                actual 最终追溯到 ObservableSubscribeOn# subscribeActual(...) 方法中的
  parent.setDisposable(scheduler.scheduleDirect(new Runnable() {
            @Override
            public void run() {
                source.subscribe(parent);  // parent 是 io.reactivex.internal.operators.observable.ObservableSubscribeOn$SubscribeOnObserver
            }
        }));

    的 source.subscribe(parent);  这里的 source 是 ObservableCreate, 

 ObservableCreate#subscribe(parent)

 ObservableCreate#subscribeActual(parent)

source.subscribe(parent);  source 是数据的源头，这里是 new ObservableOnSubscribe<Integer>() 
                           到现在为止我们都是在新线程中运行，所以数据源是在 新线程中运行的。

（数据源发射数据的过程）
ObservableEmitter#onNext(...), ObservableEmitter#onComplete(...); ObservableEmitter 是接口，实现类是 CreateEmitter

CreateEmitter#onNext(...);    io.reactivex.internal.operators.observable.ObservableCreate$CreateEmitter.java

observer.onNext(t); observer 是 parent, SubscribeOnObserver

SubscribeOnObserver#onNext(..)

actual.onNext(t);   actual 是 AObserveOnObserver,  ObserveOnObserver , io.reactivex.internal.operators.observable.ObservableObserveOn$ObserveOnObserver.java

AObserveOnObserver#onNext(...);

ObserveOnObserver#onNext(...);


ObserveOnObserver#schedule();

worker.schedule(this);   worker 是 ObservableObserveOn#subscribeActual(Observer) 中的 Scheduler.Worker w = scheduler.createWorker();
                         这里的 shecduler 是 HandlerScheduler，所以 worker 是 HandlerWorker；

Worker#schedule(Runnable, 0L, TimeUnit.NANOSECONDS);  抽象方法，由实现类实现

HandlerWorker#schedule(Runnable, 0L, TimeUnit.NANOSECONDS)；

Handler.sendMessageDelayed(); 将 Runnable 封装成 new ScheduledRunnable(handler, run)， 发送回主线程

**************************** 新线程结束 *********************************


****************************** 主线程中执行 *****************************
ScheduledRunnable#run();    io.reactivex.android.schedulers.HandlerScheduler$ScheduledRunnable.java

delegate.run();  delegate 是 Worker#schedule(Runnable, 0L, TimeUnit.NANOSECONDS) 中的 Runable, 最终是 ObserveOnObserver

ObserveOnObserver#run();

ObserveOnObserver#drainNormal();

v = q.poll(); q 是 queue， SimpleQueue； SimpleQueue 是接口，实现类是 SpscLinkedArrayQueue， SpscLinkedArrayQueue 是个生成消费队列里是从队列中取出一个值；

a.onNext(v);  a 是 Observer， Observer 是 终点 Observer

至此，整个流程结束！

在分析的基础上画了一个流程图

从整个流程可以看出
. 如果是多个 subscribeOn 线程，最终以最接近数据源的 subscribeOn 线程；
. 如果是多个 observeOn 线程，则每个线程都会执行；

分析源码的草稿以及文中的图片已经上传的 github 上， RxJava2Record

更详细的分析参考下面的文章：
. RxJava2 源码解析（一）
. RxJava2 源码解析（二）
. RxJava2 源码分析