RxJava2.0 源码剖析

这里我们先以一个最基础的使用case，来分析RxJava的实现原理。

Observable.create(ObservableOnSubscribe<Int> { emitter ->
    (1..3).forEach { emitter.onNext(it) }
})
.map { i -> "I am value $i" }
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe { str -> log(str) }

这个例子很简单：在IO线程中，发射器(被观察者)连续发射数字1，2，3，经过map转换为字符串，最后在主线程中进行输出即可。
RxJava的实现思想就是流式传递和观察者模式，下面我们以这两种模式的实现思路，来看下源码是如何实现的。

一.Observable(被观察者/发射器)

Observable是被观察者，是发起活动的对象。
先看这段代码Observable.create(ObservableOnSubscribe<Int> {} )

public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
    ...
    return new ObservableCreate<T>(source);
}

public final class ObservableCreate<T> extends Observable<T> {
    final ObservableOnSubscribe<T> source;

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

可以看到，create()方法创建了一个ObservableCreate对象，是一个继承了Observable的被观察者对象，并持有了我们外面的ObservableOnSubscribe对象，即我们用于发送时间的方法。
再接着看这段代码.map { i -> "I am value $i" }
是谁调用的map方法呢？是上一步create()返回的ObservableCreate对象。

public final <R> Observable<R> map(Function<? super T, ? extends R> mapper) {
    ...
    return new ObservableMap<T, R>(this, mapper);
}

public final class ObservableMap<T, U> extends AbstractObservableWithUpstream<T, U> {
    final Function<? super T, ? extends U> function;

    public ObservableMap(ObservableSource<T> source, Function<? super T, ? extends U> function) {
        super(source);
        this.function = function;
    }
}

abstract class AbstractObservableWithUpstream<T, U> extends Observable<U> implements HasUpstreamObservableSource<T> {
    AbstractObservableWithUpstream(ObservableSource<T> source) {
        this.source = source;
    }
}

可以看到，ObservableCreate对象的map方法，创建了一个ObservableMap对象，也是一个Observable，并持有了ObservableCreate对象作为其上游Observable对象，当然也持有我们用于做map转换的Function对象。
再接着看代码.subscribeOn(Schedulers.io())
同理，这是上一步map返回的ObservableMap对象调用的方法。

public final Observable<T> subscribeOn(Scheduler scheduler) {
    ...
    return new ObservableSubscribeOn<T>(this, scheduler);
}

public final class ObservableSubscribeOn<T> extends AbstractObservableWithUpstream<T, T> {
    final Scheduler scheduler;
    public ObservableSubscribeOn(ObservableSource<T> source, Scheduler scheduler) {
        super(source);
        this.scheduler = scheduler;
    }
}

这一步，也是创建了一个Observable对象ObservableSubscribeOn，并且持有上游对象即派发线程用的Schedule。
而.observeOn(AndroidSchedulers.mainThread())代码也是如此。

public final Observable<T> observeOn(Scheduler scheduler) {
    ...
    return new ObservableObserveOn<T>(this, scheduler, delayError, bufferSize);
}

public final class ObservableObserveOn<T> extends AbstractObservableWithUpstream<T, T> {
    public ObservableObserveOn(ObservableSource<T> source, Scheduler scheduler, boolean delayError, int bufferSize) {
        super(source);
        this.scheduler = scheduler;
    }
}

最后再来看.subscribe { str -> log(str) }
public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError,
Action onComplete, Consumer<? super Disposable> onSubscribe) {
LambdaObserver ls = new LambdaObserver(onNext, onError, onComplete, onSubscribe);
subscribe(ls);
return ls;
}
这一步创建了观察者Observer对象-LambdaObserver，并作为参数，调用了上一步的ObservableObserveOn对象的subscribe()方法，开始订阅事件。
至此，Observable被观察者对象链条，已经全部创建完毕；相当于每一步都是一个Observable，并持有上游的Observable。

二.Subscribe(订阅事件)

现在所有的Observable创建好了，并组成了链条，现在来看最后一步的subscribe()方法，是如何订阅事件的。
最后一行的subscribe()方法是上一步返回的ObservableObserveOn对象调用的。

public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError,
        Action onComplete, Consumer<? super Disposable> onSubscribe) {
    LambdaObserver<T> ls = new LambdaObserver<T>(onNext, onError, onComplete, onSubscribe);
    subscribe(ls);
    return ls;
}

public final void subscribe(Observer<? super T> observer) {
    try {
        ...
        subscribeActual(observer);
    }...
}

Observable的subscribe()方法，最终都调到了子类重写的subscribeActual()方法，所以我们只需看每个Observable子类是如何重写的即可。
先来看ObservableObserveOn类。

protected void subscribeActual(Observer<? super T> observer) {
    ...
    Scheduler.Worker w = scheduler.createWorker();
    source.subscribe(new ObserveOnObserver<T>(observer, w, delayError, bufferSize));
}

static final class ObserveOnObserver<T> extends BasicIntQueueDisposable<T>
implements Observer<T>, Runnable {
    final Observer<? super T> downstream;

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

在subscribeActual里，创建了一个ObserveOnObserver的Observer观察者，并持有传入的observer，即
LambdaObserver，作为下游的观察者；同时调用ObservableObserveOn所持有的上游被观察者的subscribe()方法，即ObservableSubscribeOn.subscribe()，并传入这个新的观察者ObserveOnObserver。
再来看ObservableSubscribeOn的subscribe()方法。

@Override
public void subscribeActual(final Observer<? super T> observer) {
    final SubscribeOnObserver<T> parent = new SubscribeOnObserver<T>(observer);
    observer.onSubscribe(parent);
    parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));
}

也是创建了一个新的观察者SubscribeOnObserver，持有传递过来的ObserveOnObserver作为其下游观察者。
同时，调用了Scheduler，发送了一个SubscribeTask。

final class SubscribeTask implements Runnable {
    private final SubscribeOnObserver<T> parent;
    SubscribeTask(SubscribeOnObserver<T> parent) {
        this.parent = parent;
    }
    @Override
    public void run() {
        source.subscribe(parent);
    }
}

假如我们的Scheduler是Schedulers.IO，那这个task将会在IO线程执行；如果是AndroidSchedulers.mainThread()，那这个task将会由主线程Handler发送到主线程执行。
这里就是subscribeOn()方法的作用实现，指定被观察者发送事件的线程。
在run方法可以看到，依然是调用上游Observable的subscribe方法，并传递当前的观察者SubscribeOnObserver，而这里的source是ObservableMap。
再来看ObservableMap的subscribe()方法。

public void subscribeActual(Observer<? super U> t) {
    source.subscribe(new MapObserver<T, U>(t, function));
}

这里比较简单，直接调用上游Observable的subscribe方法，并传递一个新的Observer，MapObserver，并持有传递进来的下游Observer。
再来看一下其上游Observable，ObservableCreate的subscribe方法。

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

这里创建了一个CreateEmitter对象，并持有下游Observer，然后，就调用上游Observable的subscribe方法，而这里的上游Observable，就是我们最开始传入的ObservableOnSubscribe对象了，同时传入了新的Emitter对象，供我们发送事件。

public interface Emitter<T> {
    void onNext(@NonNull T value);

    void onError(@NonNull Throwable error);

    void onComplete();
}

综上所述，订阅事件已经结束，我们可以发现，订阅事件的流程，和创建Observable的流程类似，都是一层一层的创建Observer和持有引用，变为链式，以便后续链式通知Observer。
相当于每一步都是一个Observer，并持有下游的Observable。

三.Observer(观察者)

现在Observable和Observer都创建好了，接下来就是发送事件和派发事件了。
我们发送事件，是通过订阅事件的最后一步，即ObservableOnSubscribe.subscribe(CreateEmitter)方法调用时，使用Emitter的onNext()、onError()方法来处罚，下面来看看例子中的emitter.onNext(1)的实现。

public void onNext(T t) {
    if (!isDisposed()) {
        observer.onNext(t);
    }
}

这里的observer就是CreateEmitter的下游Observer-MapObserver。

public void onNext(T t) {
    ...
    try {
        v = mapper.apply(t);
    } catch (Throwable ex) {
        fail(ex);
        return;
    }
    downstream.onNext(v);
}

mapper是map()方法传入的Function，用于将int指转换为string，转换后，将结果传入下游Observer的onNext()，下游Observer是SubscribeOnObserver。

public void onNext(T t) {
    downstream.onNext(t);
}

直接调用下游Observer的onNext()，即ObserveOnObserver。

public void onNext(T t) {
    if (sourceMode != QueueDisposable.ASYNC) {
        queue.offer(t);
    }
    schedule();
}
void schedule() {
    if (getAndIncrement() == 0) {
        worker.schedule(this);
    }
}
public void run() {
    ...
    drainNormal();
}
void drainNormal() {
    final SimpleQueue<T> q = queue;
    final Observer<? super T> a = downstream;
    for (;;) {
        for (;;) {
            boolean d = done;
            T v;

            try {
                v = q.poll();
            }...
            a.onNext(v);
        }...
    }
}

该Observer将值放到队列中，通过我们设置的Scheduler(Android主线程)，交回给主线程处理，处理时，调用了下游Observer的onNext()方法，下游Observer即LambdaObserver。
这里我们可以看到，observeOn(Scheduler)设置的Scheduler，就是结果传递回下一个观察者时，所在的线程。
最后，LambdaObserver就是我们最后一句代码subscribe()传入的回调对象，输出log即可。
可见，事件的发送和派发，其实就是通过链式的Observer，一层层的派发，遇到observeOn()指定scheduler的，会派发到不同的线程。

至此，RxJava的基本原理已经分析完了，其他的功能，只是不同的Observable和Observer，原理都大同小异。