Android RxJava 源码浅析

RxJava 允许我们将原本嵌套的异步任务处理，转换为链式的编程方式来处理。这样会让代码看上去更清爽，逻辑处理上也更加清晰。

而且 RxJava 在此基础上还扩展了很多函数，能提供更加丰富多样的调用方式。本片文章主要介绍一下简单链路下 RxJava 是如何运行的。

使用示例

Observable<Object> objectObservable = Observable.create(new ObservableOnSubscribe<Object>() {
            @Override
            public void subscribe(ObservableEmitter<Object> emitter) throws Exception {

            }
        });
        objectObservable.map(new Function<Object, Object>() {
            @Override
            public Object apply(Object o) throws Exception {
                return null;
            }
        });
        objectObservable.subscribeOn(Schedulers.io());
        objectObservable.observeOn(AndroidSchedulers.mainThread());
        objectObservable.subscribe(new Observer<Object>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(Object o) {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });

源码解析

Observable.create

public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
    ObjectHelper.requireNonNull(source, "source is null");
    return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));
}
// 返回 ObservableCreate 并将 ObservableOnSubscribe 保存在 source 字段中
public final class ObservableCreate<T> extends Observable<T> {
    public ObservableCreate(ObservableOnSubscribe<T> source) {
        this.source = source;
    }
}

ObservableCreate.map

public final <R> Observable<R> map(Function<? super T, ? extends R> mapper) {
    ObjectHelper.requireNonNull(mapper, "mapper is null");
    return RxJavaPlugins.onAssembly(new ObservableMap<T, R>(this, mapper));
}
// 返回 ObservableMap 并将 ObservableCreate 保存在 source 字段中， 将 Function 保存在
// function 字段中
public final class ObservableMap<T, U> extends AbstractObservableWithUpstream<T, U> {
    public ObservableMap(ObservableSource<T> source, Function<? super T, ? extends U> function) {
        super(source);
        this.function = function;
    }
}

ObservableMap.subscribeOn

public final Observable<T> subscribeOn(Scheduler scheduler) {
ObjectHelper.requireNonNull(scheduler, "scheduler is null");
    return RxJavaPlugins.onAssembly(new ObservableSubscribeOn<T>(this, scheduler));
}
// 返回 ObservableSubscribeOn 并将 ObservableMap 保存在 source 字段中，将 Scheduler.io()
// 保存在 scheduler 中
public final class ObservableSubscribeOn<T> extends AbstractObservableWithUpstream<T, T> {
    public ObservableSubscribeOn(ObservableSource<T> source, Scheduler scheduler) {
        super(source);
        this.scheduler = scheduler;
    }
}

ObservableSubscribeOn.observeOn

public final Observable<T> observeOn(Scheduler scheduler, boolean delayError, int bufferSize) {
    ObjectHelper.requireNonNull(scheduler, "scheduler is null");
    ObjectHelper.verifyPositive(bufferSize, "bufferSize");
    return RxJavaPlugins.onAssembly(new ObservableObserveOn<T>(this, scheduler, delayError, bufferSize));
}

// 返回 ObservableObserveOn 并将 ObservableSubscribeOn 保存在 source 字段中
// 将 AndroidSchedulers.mainThread() 保存在 scheduler 字段中
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;
        this.delayError = delayError;
        this.bufferSize = bufferSize;
    }
}

ObservableObserveOn.subscribe

    public final void subscribe(Observer<? super T> 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;
        }
    }

实际上调用到了 ObservableObserveOn 的 subscribeActual 方法

@Override
protected void subscribeActual(Observer<? super T> observer) {
    if (scheduler instanceof TrampolineScheduler) {
        source.subscribe(observer);
    } else {
        Scheduler.Worker w = scheduler.createWorker();
        // 将 observer 包装成了 ObservenObserver 传递给了上一层
        source.subscribe(new ObserveOnObserver<T>(observer, w, delayError, bufferSize));
    }
}

source 是指 ObservableSubscribeOn

@Override
public void subscribeActual(final Observer<? super T> observer) {
    // 封装为了 SubscribeOnObserver
    final SubscribeOnObserver<T> parent = new SubscribeOnObserver<T>(observer);
    // 执行了 observer 的 subscribe 方法
    observer.onSubscribe(parent);
    // 主要是通过 scheduler.scheduleDirect 将线程切换到 scheduler 中， 这里是 Schedulers
    //.io()
    parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));
}

Scheculer.io()

static {
    IO = RxJavaPlugins.initIoScheduler(new IOTask());
}

static final class IOTask implements Callable<Scheduler> {
    @Override
    public Scheduler call() throws Exception {
        return IoHolder.DEFAULT;
    }
}
static final class IoHolder {
    static final Scheduler DEFAULT = new IoScheduler();
}

所以 scheduler.scheduleDirect 实际是执行 IoScheduler 的 scheduleDirect 方法

public Disposable scheduleDirect(@NonNull Runnable run, long delay, @NonNull TimeUnit unit) {
    // 创建了 EventLoopWorker
    final Worker w = createWorker();

    final Runnable decoratedRun = RxJavaPlugins.onSchedule(run);

    DisposeTask task = new DisposeTask(decoratedRun, w);
    // 执行了 work 的 schedule 方法
    w.schedule(task, delay, unit);

    return task;
}

public Worker createWorker() {
    return new EventLoopWorker(pool.get());
}

static final class EventLoopWorker extends Scheduler.Worker {
        public Disposable schedule(@NonNull Runnable action, long delayTime, @NonNull TimeUnit unit) {
            if (tasks.isDisposed()) {
                // don't schedule, we are unsubscribed
                return EmptyDisposable.INSTANCE;
            }
            // 执行 threadWorker 的 scheduleActual 方法
            return threadWorker.scheduleActual(action, delayTime, unit, tasks);
        }
}

// 可以看到最后执行的是 NewThreadWorker 的 scheduleActual 方法
static final class ThreadWorker extends NewThreadWorker {
    private long expirationTime;
    ThreadWorker(ThreadFactory threadFactory) {
        super(threadFactory);
        this.expirationTime = 0L;
    }
    public long getExpirationTime() {
        return expirationTime;
    }
    public void setExpirationTime(long expirationTime) {
        this.expirationTime = expirationTime;
    }
}

public class NewThreadWorker extends Scheduler.Worker implements Disposable {
    // excutor 为线程池
    private final ScheduledExecutorService executor;
    @NonNull
    public ScheduledRunnable scheduleActual(final Runnable run, long delayTime, @NonNull TimeUnit unit, @Nullable DisposableContainer parent) {
        Runnable decoratedRun = RxJavaPlugins.onSchedule(run);

        ScheduledRunnable sr = new ScheduledRunnable(decoratedRun, parent);

        if (parent != null) {
            if (!parent.add(sr)) {
                return sr;
            }
        }

        Future<?> f;
        try {
            // 通过 executor 直接执行或者延时执行
            if (delayTime <= 0) {
                f = executor.submit((Callable<Object>)sr);
            } else {
                f = executor.schedule((Callable<Object>)sr, delayTime, unit);
            }
            sr.setFuture(f);
        } catch (RejectedExecutionException ex) {
            if (parent != null) {
                parent.remove(sr);
            }
            RxJavaPlugins.onError(ex);
        }

        return sr;
    }
}

所以 ObservableSubscribeOn.subscribeActual 执行完后， 后续的操作都在 IoScheduler 指定的线程池中进行。

继续往下看， 线程池最终会执行到 SubscribeTask 的 run 方法， 实际上又执行到了 source.subscribe 方法

final class SubscribeTask implements Runnable {
    private final SubscribeOnObserver<T> parent;

    SubscribeTask(SubscribeOnObserver<T> parent) {
        this.parent = parent;
    }

    @Override
    public void run() {
        source.subscribe(parent);
    }
}

source 指的是 ObservableMap ， 继续往下看

public final class ObservableMap<T, U> extends AbstractObservableWithUpstream<T, U> {
    // 传入的是 SubscribeOnObserver
    public void subscribeActual(Observer<? super U> t) {
        // 包装成 MapObserver 继续往上传入
        source.subscribe(new MapObserver<T, U>(t, function));
    }
}

这里的source 指的是 ObserveableCreate

public final class ObservableCreate<T> extends Observable<T> {
    protected void subscribeActual(Observer<? super T> observer) {
        CreateEmitter<T> parent = new CreateEmitter<T>(observer);
        // 执行 observer 的 obSubscribe 方法
        observer.onSubscribe(parent);

        try {
            // 继续执行 subscribe 方法 传入 CreateEmitter
            source.subscribe(parent);
        } catch (Throwable ex) {
            Exceptions.throwIfFatal(ex);
            parent.onError(ex);
        }
    }
}    

这里的 source 指的是 ObservableOnSubscribe , 即传入 Observable.create 方法的参数

Observable.create(new ObservableOnSubscribe<Object>() {
    @Override
    public void subscribe(ObservableEmitter<Object> emitter) throws Exception {
        // 在这里一般需执行 emitter.onNext()
    }
})

解下来是第三个流程， 基本就是走 onNext 方法， 搜先看看 emitter 的 onNext 方法

static final class CreateEmitter<T>
extends AtomicReference<Disposable>
implements ObservableEmitter<T>, Disposable {
    @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 指的是 MapObserver
            observer.onNext(t);
        }
    }
}

MapObserver 的 onNext 方法

static final class MapObserver<T, U> extends BasicFuseableObserver<T, U> {
    // 这个是  BasicFuseableObservable 的属性， 可以看到实际就是构造方法传入的 observer
    protected final Observer<? super R> downstream;
    public BasicFuseableObserver(Observer<? super R> downstream) {
        this.downstream = downstream;
    }
    
    @Override
    public void onNext(T t) {
        if (done) {
            return;
        }
        if (sourceMode != NONE) {
            downstream.onNext(null);
            return;
        }
        U v;
        try {
            // 会先执行 apply 方法
            v = ObjectHelper.requireNonNull(mapper.apply(t), "The mapper function returned a null value.");
        } catch (Throwable ex) {
            fail(ex);
            return;
        }
        // 让后再执行 downStrean 的 onNext
        downstream.onNext(v);
    }
}

这个 downstream 根据之前的分析，实际上就是 SubscribeOnObserver.

static final class SubscribeOnObserver<T> extends AtomicReference<Disposable> implements Observer<T>, Disposable {
    @Override
    public void onNext(T t) {
        downstream.onNext(t);
    }
}

由于 SubscribeOn 的切换是发生在 subscribeActual 中， 所以 onNext 中不会做任何处理，直接执行 onNext.

这个 downstream 指的是 ObserveOnObserver

static final class ObserveOnObserver<T> extends BasicIntQueueDisposable<T>
implements Observer<T>, Runnable {
        static final class ObserveOnObserver<T> extends BasicIntQueueDisposable<T>
        @Override
        public void onNext(T t) {
            if (done) {
                return;
            }

            if (sourceMode != QueueDisposable.ASYNC) {
                queue.offer(t);
            }
            schedule();
        }
        // 通过 worker 来执行 schedule 操作
        void schedule() {
            if (getAndIncrement() == 0) {
                worker.schedule(this);
            }
        }

        // worker 通过 scheduler 来创建的，然后传入的
        ObserveOnObserver(Observer<? super T> actual, Scheduler.Worker worker, boolean delayError, int bufferSize) {
            this.downstream = actual;
            this.worker = worker;
            this.delayError = delayError;
            this.bufferSize = bufferSize;
        }

}

这个 scheduler 通过传参数来确认，为 AndroidSchedulers.mainThread()

    public static Scheduler mainThread() {
        return RxAndroidPlugins.onMainThreadScheduler(MAIN_THREAD);
    }

    private static final Scheduler MAIN_THREAD = RxAndroidPlugins.initMainThreadScheduler(
            new Callable<Scheduler>() {
                @Override public Scheduler call() throws Exception {
                    return MainHolder.DEFAULT;
                }
            });
    // 可以看到实际上是一个 HandlerScheduler 然后传入了一个主线程Looper 的 Handler
    private static final class MainHolder {
        static final Scheduler DEFAULT
            = new HandlerScheduler(new Handler(Looper.getMainLooper()), false);
    }

再看看 HandlerWorker

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

private static final class HandlerWorker extends Worker {
    private final Handler handler;
    private final boolean async;

    private volatile boolean disposed;

    HandlerWorker(Handler handler, boolean async) {
        this.handler = handler;
        this.async = async;
    }

    @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) {
            return Disposables.disposed();
        }

        run = RxJavaPlugins.onSchedule(run);

        // 最终就是执行了 run 参数的 run 方法， run 参数实际就是 ObserveOnObserver
        ScheduledRunnable scheduled = new ScheduledRunnable(handler, run);

        Message message = Message.obtain(handler, scheduled);
        message.obj = this; // Used as token for batch disposal of this worker's runnables.

        if (async) {
            message.setAsynchronous(true);
        }

        // 通过 handler 来处理，实际上就切换到主线程了
        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;
    }

    @Override
    public void dispose() {
        disposed = true;
        handler.removeCallbacksAndMessages(this /* token */);
    }

    @Override
    public boolean isDisposed() {
        return disposed;
    }
}
static final class ObserveOnObserver<T> extends BasicIntQueueDisposable<T>
    implements Observer<T>, Runnable {
        @Override
        public void run() {
            // 这个参数在过程中并没有改变，所以应该执行 else 此时已经切换了线程
            if (outputFused) {
                drainFused();
            } else {
                drainNormal();
            }
        }

         void drainNormal() {
            int missed = 1;

            final SimpleQueue<T> q = queue;
            // 实际上就是 subscribe 方法传递的 observer 了
            final Observer<? super T> a = downstream;

            for (;;) {
                if (checkTerminated(done, q.isEmpty(), a)) {
                    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) {
                        break;
                    }
                    // 最后执行了 onNext
                    a.onNext(v);
                }

                missed = addAndGet(-missed);
                if (missed == 0) {
                    break;
                }
            }
        }
}

这样一套简单的 RxJava 的流程就执行完了。

个人总结

总结来看，总共分为三个流程。

从 Observeble.create 到 subscribe() , 一层层将参数封装为 ObservableXXXX 对象。

从 ObservebleObserveOn.subscribeActual 到 ObservableOnSubscribe. subscribe 方法， 将参数封装为 xxxObserver 一层层向上传递

最后，从 CreateEmitter 的 onNext 到 Observer 的 onNext , 一层层解析执行 onNext 方法， 中间执行 apply 方法将参数进行处理后返回。

其中 subscribeOn 的线程切换在 subscribeActual 中， observeOn 的线程切换在 onNext 中。

实际上， RxJava 的设计是一种变式的观察者模式， 下一层只需观察上一层的执行结果即可， 而不是像传统的观察者模式一样，所有的观察者都去观察同一个观察着， 可以说，每一个对象既是观察者，也是被观察着。