【拆轮子系列】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 AbstractObservableWithUpstreamAbstractObservableWithUpstream extends Observable implements HasUpstreamObservableSourceObservableSubscribeOn 和  ObservableObserveOn 都 extends Observable, 所以它们都是 Observale 对象，所以，都会调用它们的 subscribeActual() 方法ObservableSubscribeOn#subscribeActual()ObservableObserveOn#subscribeActual()Observable implements ObservableSourcepublic 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(); 抽象方法，由实现类实现 这里是 IoSchedulerIoScheduler#createWorker();  返回 EventLoopWorkerWorker.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 是接口，实现类是 CreateEmitterCreateEmitter#onNext(...);    io.reactivex.internal.operators.observable.ObservableCreate$CreateEmitter.javaobserver.onNext(t); observer 是 parent, SubscribeOnObserverSubscribeOnObserver#onNext(..)actual.onNext(t);   actual 是 AObserveOnObserver,  ObserveOnObserver , io.reactivex.internal.operators.observable.ObservableObserveOn$ObserveOnObserver.javaAObserveOnObserver#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.javadelegate.run();  delegate 是 Worker#schedule(Runnable, 0L, TimeUnit.NANOSECONDS) 中的 Runable, 最终是 ObserveOnObserverObserveOnObserver#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 源码分析