Android rxjava源碼淺析

下面談談我的理解

rxjava原理說白了就是三條流：

• API構建流
• 事件訂閱流
• 事件回調流

這裏結合retrofit以接口調用流程爲例做源碼分析

retrofit源碼淺析有說到，retrofit設置RxJava2CallAdapterFactory最終會創建CallObservable，在CallObservable中發起網絡請求。

如此說來

retrofit配合rxjava網絡調用流程

CallObservable.
    .subscribeOn(Schedulers.io())
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe{bean->

    }

1. 構建流

既然是鏈式調用，各種操作符必然都生成同類型對象。

• CallObservable--->Observable

• subscribeOn--->ObservableSubscribeOn
  --->AbstractObservableWithUpstream--->Observable

    public final Observable<T> subscribeOn(Scheduler scheduler) {
        ObjectHelper.requireNonNull(scheduler, "scheduler is null");
        return RxJavaPlugins.onAssembly(new ObservableSubscribeOn<T>(this, scheduler));
    }

AbstractObservableWithUpstream抽象類實現HasUpstreamObservableSource接口

重寫了source()方法

    protected final ObservableSource<T> source;

    AbstractObservableWithUpstream(ObservableSource<T> source) {
        this.source = source;
    }

    @Override
    public final ObservableSource<T> source() {
        return source;
    }

subscribeOn操作符--->new ObservableSubscribeOn<T>(this, scheduler)

此處this即爲source，也就是上游Observable作爲下游source對象。

• observeOn--->ObservableObserveOn
  --->AbstractObservableWithUpstream--->Observable

    public final Observable<T> observeOn(Scheduler scheduler) {
        return observeOn(scheduler, false, bufferSize());
    }

    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繼承AbstractObservableWithUpstream實現HasUpstreamObservableSource接口保存了上游Observable對象。

• subscribe開始訂閱

2. 訂閱流

Observable實現ObservableSource接口，重寫訂閱方法。

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

上述構建流調用Observable.subscribe(Consumer<? super T> onNext)

    public final Disposable subscribe(Consumer<? super T> onNext) {
        return subscribe(onNext, Functions.ON_ERROR_MISSING, Functions.EMPTY_ACTION, Functions.emptyConsumer());
    }

    public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError,
            Action onComplete, Consumer<? super Disposable> onSubscribe) {
        ObjectHelper.requireNonNull(onNext, "onNext is null");
        ObjectHelper.requireNonNull(onError, "onError is null");
        ObjectHelper.requireNonNull(onComplete, "onComplete is null");
        ObjectHelper.requireNonNull(onSubscribe, "onSubscribe is null");

        LambdaObserver<T> ls = new LambdaObserver<T>(onNext, onError, onComplete, onSubscribe);

        subscribe(ls);

        return ls;
    }

    @SchedulerSupport(SchedulerSupport.NONE)
    @Override
    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) {
            throw e;
        } catch (Throwable e) {
            Exceptions.throwIfFatal(e);
            RxJavaPlugins.onError(e);

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

無論哪個subscribe()方法最終都會走到ObservableSource接口subscribe(observer)方法

內部調用 subscribeActual(observer)

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

subscribeActual(observer)是個抽象方法，各Observable包裝類重寫該方法。

subscribe訂閱邏輯實際上就是調用Observable.subscribeActual(observer)方法。

回到訂閱流，上述構建流最後由observeOn操作符生成ObservableObserveOn對象。

即ObservableObserveOn.subscribeActual(observer)

    @Override
    protected void subscribeActual(Observer<? super T> observer) {
        if (scheduler instanceof TrampolineScheduler) {
            source.subscribe(observer);
        } else {
            Scheduler.Worker w = scheduler.createWorker();

            //包裝observer
            source.subscribe(new ObserveOnObserver<T>(observer, w, delayError, bufferSize));
        }
    }

source.subscribe(observer)

前面訂閱流說過source是上游Observable對象即

subscribeOn操作符生成的ObservableSubscribeOn對象

ObservableSubscribeOn.subscribeActual(observer)

    @Override
    public void subscribeActual(final Observer<? super T> observer) {
        //包裝下游observer
        final SubscribeOnObserver<T> parent = new SubscribeOnObserver<T>(observer);

        observer.onSubscribe(parent);

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

這裏繞了一下

new SubscribeTask(parent)

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

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

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

SubscribeTask實現Runnable接口

在run()方法中調用source.subscribe(parent)

也就是上游對象CallObservable.subscribeActual(observer)

  @Override protected void subscribeActual(Observer<? super Response<T>> observer) {
    Call<T> call = originalCall.clone();
    observer.onSubscribe(new CallDisposable(call));

    boolean terminated = false;
    try {
      //okhttp同步請求
      Response<T> response = call.execute();
      if (!call.isCanceled()) {
        observer.onNext(response);
      }
      if (!call.isCanceled()) {
        terminated = true;
        observer.onComplete();
      }
    } catch (Throwable t) {
      Exceptions.throwIfFatal(t);
      if (terminated) {
        RxJavaPlugins.onError(t);
      } else if (!call.isCanceled()) {
        try {
          observer.onError(t);
        } catch (Throwable inner) {
          Exceptions.throwIfFatal(inner);
          RxJavaPlugins.onError(new CompositeException(t, inner));
        }
      }
    }
  }

訂閱流由下游回到上游

網絡請求Call封裝到Disposable

observer.onSubscribe(new CallDisposable(call));

  private static final class CallDisposable implements Disposable {
    private final Call<?> call;

    CallDisposable(Call<?> call) {
      this.call = call;
    }

    @Override public void dispose() {
      call.cancel();
    }

    @Override public boolean isDisposed() {
      return call.isCanceled();
    }
  }

CallObservable.subscribeActual()中發起網絡請求

然後回調observer.onSubscribe()/onNext()/onComplete()/onError()

3. 回調流

訂閱流中subscribeActual()方法調用上游Observable.subscribe(observer)

將下游observer對象包裝傳遞到上游

CallObservable中observer.onNext()即調用下游observer對象onNext()方法。

回看ObservableSubscribeOn.subscribeActual()

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

parent--->SubscribeOnObserver

        final Observer<? super T> downstream;

        SubscribeOnObserver(Observer<? super T> downstream) {
            this.downstream = downstream;
            this.upstream = new AtomicReference<Disposable>();
        }

        @Override
        public void onSubscribe(Disposable d) {
            DisposableHelper.setOnce(this.upstream, d);
        }

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

        @Override
        public void onError(Throwable t) {
            downstream.onError(t);
        }

        @Override
        public void onComplete() {
            downstream.onComplete();
        }

downstream.onNext(t)繼續調用下游Observer.onNext()

回看ObservableObserveOn.subscribeActual()

下游Observer--->ObserveOnObserver

    @Override
    protected void subscribeActual(Observer<? super T> observer) {
        if (scheduler instanceof TrampolineScheduler) {
            source.subscribe(observer);
        } else {
            //scheduler是ObserveOn操作符傳入的AndroidSchedulers.mainThread()
            Scheduler.Worker w = scheduler.createWorker();

            //ObserveOnObserver傳遞到上游
            source.subscribe(new ObserveOnObserver<T>(observer, w, delayError, bufferSize));
        }
    }

順帶看下線程切換

AndroidSchedulers.mainThread()

    private static final class MainHolder {
        static final Scheduler DEFAULT
            = new HandlerScheduler(new Handler(Looper.getMainLooper()), false);
    }

    private static final Scheduler MAIN_THREAD = RxAndroidPlugins.initMainThreadScheduler(
            new Callable<Scheduler>() {
                @Override public Scheduler call() throws Exception {
                    return MainHolder.DEFAULT;
                }
            });

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

MainHolder.DEFAULT即HandlerScheduler--->new Handler(Looper.getMainLooper())

封裝了主線程handler

RxAndroidPlugins

    public static Scheduler initMainThreadScheduler(Callable<Scheduler> scheduler) {
        if (scheduler == null) {
            throw new NullPointerException("scheduler == null");
        }
        Function<Callable<Scheduler>, Scheduler> f = onInitMainThreadHandler;
        if (f == null) {
            return callRequireNonNull(scheduler);
        }
        return applyRequireNonNull(f, scheduler);
    }

    public static Scheduler onMainThreadScheduler(Scheduler scheduler) {
        if (scheduler == null) {
            throw new NullPointerException("scheduler == null");
        }
        Function<Scheduler, Scheduler> f = onMainThreadHandler;
        if (f == null) {
            return scheduler;
        }
        return apply(f, scheduler);
    }

AndroidSchedulers.mainThread()返回HandlerScheduler

HandlerScheduler.createWorker()--->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
        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);

            ScheduledRunnable scheduled = new ScheduledRunnable(handler, run);

            Message message = Message.obtain(handler, scheduled);
            message.obj = this; 

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

            handler.sendMessageDelayed(message, unit.toMillis(delay));

            if (disposed) {
                handler.removeCallbacks(scheduled);
                return Disposables.disposed();
            }

            return scheduled;
        }
    }

通過handler和message切換到主線程執行Runnable

回到ObserveOnObserver.onNext()

        final Scheduler.Worker worker;

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

        @Override
        public void onNext(T t) {
            if (done) {
                return;
            }

            if (sourceMode != QueueDisposable.ASYNC) {
                queue.offer(t);
            }
            schedule();
        }

        void schedule() {
            if (getAndIncrement() == 0) {
                worker.schedule(this);
            }
        }

        @Override
        public void run() {
            if (outputFused) {
                drainFused();
            } else {
                drainNormal();
            }
        }

ObserveOnObserver實現Runnable接口

worker.schedule(this)

        public Disposable schedule(@NonNull Runnable run) {
            return schedule(run, 0L, TimeUnit.NANOSECONDS);
        }

        public abstract Disposable schedule(@NonNull Runnable run, long delay, @NonNull TimeUnit unit);

調用到上述實現類

HandlerWorker.schedule(Runnable run, long delay, TimeUnit unit)

Runnable即ObserveOnObserver

ObserveOnObserver.run()

        @Override
        public void run() {
            if (outputFused) {
                drainFused();
            } else {
                drainNormal();
            }
        }

ObserveOnObserver.drainNormal()

        void drainNormal() {
            ...
            final Observer<? super T> a = downstream;
            ...
            a.onNext(v);
        }

繼續調用下游Observer.onNext

也就是subscribe操作符中用戶自定義的Observer.onNext()

至此回調流結束，整個事件消費完畢。

ObserveOn操作符切換線程，影響回調流執行。也就是操作符下游Observer回調方法執行所在線程。

繼續看subscribeOn操作符

構建流中subscribeOn(Schedulers.io())

Schedulers.io() static塊中初始化

    @NonNull
    static final Scheduler IO;

    public static Scheduler io() {
        return RxJavaPlugins.onIoScheduler(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();
    }

IoScheduler

    static final RxThreadFactory WORKER_THREAD_FACTORY;

    public IoScheduler() {
        this(WORKER_THREAD_FACTORY);
    }

    public IoScheduler(ThreadFactory threadFactory) {
        this.threadFactory = threadFactory;
        this.pool = new AtomicReference<CachedWorkerPool>(NONE);
        start();
    }

    static {
        ...
        WORKER_THREAD_FACTORY = new RxThreadFactory(WORKER_THREAD_NAME_PREFIX, priority);

        NONE = new CachedWorkerPool(0, null, WORKER_THREAD_FACTORY);
        ...
    }

RxJavaPlugins

    @NonNull
    public static Scheduler initIoScheduler(@NonNull Callable<Scheduler> defaultScheduler) {
        ObjectHelper.requireNonNull(defaultScheduler, "Scheduler Callable can't be null");
        Function<? super Callable<Scheduler>, ? extends Scheduler> f = onInitIoHandler;
        if (f == null) {
            return callRequireNonNull(defaultScheduler);
        }
        return applyRequireNonNull(f, defaultScheduler);
    }

    @NonNull
    public static Scheduler onIoScheduler(@NonNull Scheduler defaultScheduler) {
        Function<? super Scheduler, ? extends Scheduler> f = onIoHandler;
        if (f == null) {
            return defaultScheduler;
        }
        return apply(f, defaultScheduler);
    }

回到ObservableSubscribeOn.subscribeActual()

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

scheduler.scheduleDirect()

    public Disposable scheduleDirect(@NonNull Runnable run) {
        return scheduleDirect(run, 0L, TimeUnit.NANOSECONDS);
    }

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

        final Runnable decoratedRun = RxJavaPlugins.onSchedule(run);

        DisposeTask task = new DisposeTask(decoratedRun, w);

        w.schedule(task, delay, unit);

        return task;
    }

createWorker()是抽象方法，這裏調用上述實現類IoScheduler.createWorker()

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

    static final class EventLoopWorker extends Scheduler.Worker {
        private final CompositeDisposable tasks;
        private final CachedWorkerPool pool;
        private final ThreadWorker threadWorker;

        EventLoopWorker(CachedWorkerPool pool) {
            this.pool = pool;
            this.tasks = new CompositeDisposable();
            this.threadWorker = pool.get();
        }

        @Override
        public Disposable schedule(@NonNull Runnable action, long delayTime, @NonNull TimeUnit unit) {
            if (tasks.isDisposed()) {
                return EmptyDisposable.INSTANCE;
            }

            return threadWorker.scheduleActual(action, delayTime, unit, tasks);
        }
    }

w.schedule(task, delay, unit)即EventLoopWorker.schedule()

threadWorker.scheduleActual()

threadWorker本身有緩存池操作，這裏不細說。

threadWorker--->NewThreadWorker

NewThreadWorker.scheduleActual()

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

將訂閱流中SubscribeTask這個Runnable包裝成ScheduledRunnable

executor.submit()調用線程池執行

subscribeOn將上游訂閱操作Observable.subscribe()封裝到runnable中在對應的線程調度Schedulers中執行。其影響操作符上游訂閱流執行所在線程。

無論是subscribeOn還是observeOn，本質都是藉助不同的Schedulers調度線程。

不同的是Android主線程需藉助handler切換，工作線程使用線程池。