前言

16年的時候寫過兩篇關於Rxjava 1.0 的源碼分析，時過境遷，現在早已是2.0 了。2.0 的代碼邏輯，封裝，更爲易懂，也包含了一些新特性背壓，面向切面等等。所以決定，寫篇文章分析RxJava 2.0

關於RxJava，從表面上看起來很容易使用，但是如果理解不夠深刻，使用過程中，往往會出現一些問題，所以我寫了系列文章，從入門到精通，從簡單的使用到部分源碼詳解，希望能給讀者一個質的飛躍：
1、RxJava之一——一次性學會使用RxJava RxJava簡單的使用和使用它的好處
2、RxJava之二——Single和Subject 與Observable舉足輕重的類，雖然用的少，但應該知道
3、RxJava之三——RxJava 2.0 全部操作符示例
4、RxJava之四—— Lift()詳解想要了解Operators，Lift()一定要學習
5、RxJava之五—— observeOn()與subscribeOn()的詳解Scheduler線程切換的原理
6、RxJava之六——RxBus 通過RxJava來替換EventBus
7、RxJava之七——RxJava 2.0 圖文分析create()、 subscribe()、map()、observeOn()、subscribeOn()源碼這張圖可能是全網最詳細明瞭的圖

Rxjava2.x 與1.x 的相關文章：

關於 RxJava 最友好的文章—— RxJava 2.0 全新來襲
官方文檔：What’s different in 2.0
RxJava github

示例

Rxjava的使用流程，相信大家都很清楚了，以下面這個簡單的demo，重點分析一下create()、 subscribe()、map()、observeOn()、subscribeOn()源碼。只要瞭解這些源碼，再去看其他的類都會有似曾相識的感覺

        Observable.create(object : ObservableOnSubscribe<Int> {
            override fun subscribe(emitter: ObservableEmitter<Int>) {
                  emitter.onNext(1)
            }})
            .map(object : Function<Int, String> {
                override fun apply(t: Int): String {
                    return t.toString()
                }}
            )
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(object : Observer<String> {
                override fun onComplete() {
                }

                override fun onSubscribe(d: Disposable) {
                }

                override fun onNext(t: String) {
                }

                override fun onError(e: Throwable) {
                }
            })

在看源代碼時，被其中一層一層的封裝和調用，類名搞的暈暈的，一不留神就不知道誰是誰。
我把源代碼的簡單流程，畫了個圖，先腦子裏有個整體的輪廓，再去看代碼，會清晰很多

關於流程圖的介紹：

這張圖，可能是全網關於rxjava2 大體流程，最詳細的圖。爲了排版和方便理解，簡化了函數的關係，忽略了很多細節

綠色模塊表示訂閱者，例如 Observable 或 Flowable，或者他們的子類
藍色模塊表示觀察者，例如 Observer 或Subscriber，或者他們的子類
青色模塊表示數據發送，例如：ObservableOnSubscribe，ObservableSource，等等
黃色模塊表示切換了線程
每個模塊右上角表示當前類的名稱
綠色的線表示函數調用
藍色的線表示訂閱
紅色的線表示數據發送
黑色的線表示對象是什麼或者對象從哪裏來的

基本流程

還是以上面的demo爲例，拋開操作符，只分析主要流程

先來看下，demo中都使用哪些類和接口：

Observable 訂閱者
Observer 觀察者
ObservableOnSubscribe 數據發送源

public interface ObservableOnSubscribe<T> {

    // ObservableEmitter 也是一個接口，它繼承接口Emitter
    void subscribe(@NonNull ObservableEmitter<T> emitter) throws Exception;
}

//這個接口，有常見的幾種函數。在demo中可以看到，調用的oNext 就是這個接口的函數
public interface Emitter<T> {
    void oNext(@NonNull T value);
    void onError(@NonNull Throwable error);
    void onComplete();
}

下面一步一步進入源碼：

create

    public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
         // 判斷非空
        ObjectHelper.requireNonNull(source, "source is null");
        //RxJavaPlugins 相當於是切面編程，會對所有的中間訂閱者進行自定義修改，如果沒有設置過。就直接當前參數
        //創建一個 ObservableCreate，它就是上圖中的綠色模塊
        return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));
    }

來看一個RxJavaPlugins.onAssembly

    public static <T> Observable<T> onAssembly(@NonNull Observable<T> source) {
        // onObservableAssembly  需要手動設置，實現切面效果
        Function<? super Observable, ? extends Observable> f = onObservableAssembly;
        //如果沒有設置 就是null，直接返回參數source
        if (f != null) {
            return apply(f, source);
        }
        return source;
    }

create 傳入的是ObservableOnSubscribe 類型參數，需要的Observable返回類型，這裏的ObservableCreate 繼承了Observable 並實現接口subscribeActual，引用了ObservableOnSubscribe 並調用它的接口subscribe，所以它算是一種適配器模式。

public final class ObservableCreate<T> extends Observable<T> {

    // 每個Observable 的實現類，都有一個source，表示的是上游
    final ObservableOnSubscribe<T> source;

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

    // subscribe 最終會調用到這裏
    // observer 是觀察者，它裏面實現了onNext、onSubscribe 等 這些函數
    @Override
    protected void subscribeActual(Observer<? super T> observer) {
        CreateEmitter<T> parent = new CreateEmitter<T>(observer);
        //調用了觀察者的onSubscribe 方法
        observer.onSubscribe(parent);

        try {
            //這個上游source 就是demo中的ObservableOnSubscribe 實現，
            //調用了subscribe，以本例來說，就會執行 emitter.onNext(1)
            // 那麼問題來了，subscribeActual 會在什麼時候執行呢？
            source.subscribe(parent);
        } catch (Throwable ex) {
            Exceptions.throwIfFatal(ex);
            parent.onError(ex);
        }
    }

需要注意，代碼執行到這裏，是誰調用了subscribe，create() 返回的是Observable類型 ObservableCreate，所以是ObservableCreate調用了subscribe，那麼關於Observable的接口，自然也會調用到ObservableCreate

    public final void subscribe(Observer<? super T> observer) {
        ObjectHelper.requireNonNull(observer, "observer is null");
        try {
            // 面向切面的設置，如果沒有設置，直接返回observer
            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");
            //以本例來看，就是執行ObservableCreate 中的subscribeActual 
            subscribeActual(observer);
        } catch (NullPointerException e) { // NOPMD
            throw e;
        } catch (Throwable e) {
            ... 省略代碼 ...
        }
    }

ObservableCreate 類
    // subscribe 最終會調用到這裏
    // observer 是觀察者，它裏面實現了onNext、onSubscribe 等 這些函數
    @Override
    protected void subscribeActual(Observer<? super T> observer) {
         // 把觀察者，封裝成CreateEmitter
        CreateEmitter<T> parent = new CreateEmitter<T>(observer);
        //調用了觀察者的onSubscribe 方法
        observer.onSubscribe(parent);

        try {
            //這個上游source 就是demo中的ObservableOnSubscribe 實現，
            //調用了subscribe，以本例來說，就會執行 emitter.onNext(1)，也就是執行了parent.onNext(1)
            source.subscribe(parent);
        } catch (Throwable ex) {
            Exceptions.throwIfFatal(ex);
            parent.onError(ex);
        }
    }

最後進入CreateEmitter 來看一下：

 static final class CreateEmitter<T>
    extends AtomicReference<Disposable>
    implements ObservableEmitter<T>, Disposable {

        private static final long serialVersionUID = -3434801548987643227L;

        final Observer<? super T> observer;

        CreateEmitter(Observer<? super T> observer) {
            //demo 中的observer 最終被傳遞到這裏
            this.observer = observer;
        }

       // 在subscribeActual 調用到這裏
        @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()) {
                //如果沒有disposed ，就會執行demo中observer的onNext
                observer.onNext(t);
            }
        }
          ... 省略代碼 ...

        @Override
        public void onComplete() {
            //如果沒有被dispose，會調用Observer的onComplete()方法
            if (!isDisposed()) {
                try {
                    observer.onComplete();
                } finally {
                    //執行完調用dispose
                    dispose();
                }
            }
        }

       ... 省略代碼 ...
    }

源碼看到這裏，再去看上圖，思路應該更清晰，但是應該對整圖還不是很瞭解。

仔細總結一下會發現，在create後，創建了ObservableCreate ，他知道上游（source），知道被訂閱後的處理方式（subscribeActual ）也就是如何把數據發給下游，但是它需要等待調用subscribe，纔會最終觸發這個流程。

而且ObservableCreate 是繼承於Observable ，對設計模式敏感的小夥伴，可能會想到裝飾着模式，沒錯，所謂的操作符，無非就是用裝飾着模式包裹一層，讓他也知道上游（source），知道如何數據發給下游（實現subscribeActual ），最終subscribe 一調用，這個過程就被觸發。

如果感覺混亂，沒關係，下面跟着源碼走一下，就會豁然開朗

map操作符

調用map，會執行下面的函數

    public final <R> Observable<R> map(Function<? super T, ? extends R> mapper) {
        ObjectHelper.requireNonNull(mapper, "mapper is null");
        //發現了嗎，上面的create 創建ObservableCreate  ， map 創建了 ObservableMap 
        //沒錯他們都是Observable的子類
        return RxJavaPlugins.onAssembly(new ObservableMap<T, R>(this, mapper));
    }

有了新的Observable （ObservableMap），那肯定得有新的Observer，不然ObservableMap和誰關聯呢？是的，新的Observer就是 MapObserver

//AbstractObservableWithUpstream 繼承於Observable，有成員變量source
public final class ObservableMap<T, U> extends AbstractObservableWithUpstream<T, U> {
    final Function<? super T, ? extends U> function;

    //這裏傳入的是this，也就是本例中的ObservableCreate ，它繼承於Observable 繼承於ObservableSource
    public ObservableMap(ObservableSource<T> source, Function<? super T, ? extends U> function) {
        // 把上游的源保存起來
        super(source);
        //保存當前的操作函數，也就是demo 中map 裏實現的函數
        this.function = function;
    }

    // 太熟悉了，又是它，等ObservableMap 調用subscribe 的時候，會調用到這裏
    @Override
    public void subscribeActual(Observer<? super U> t) {
       // 調用了上游（source）的subscribe，這就相當於觸發了上游
       // 傳入的參數是MapObserver，聯想到上面的subscribe 直接訂閱Observer
       // 這個MapObserver繼承Observer，它的參數t 也是Observer，也就是把下游的Observer 包裹了一層，傳遞給上游。這正是裝飾者模式
       // 本例中emitter.onNext(1)執行後，也就是會執行MapObserver中的onNext
        source.subscribe(new MapObserver<T, U>(t, function));
    }

     //BasicFuseableObserver 繼承了Observer，有成員變量downstream、upstream 等
    static final class MapObserver<T, U> extends BasicFuseableObserver<T, U> {
        final Function<? super T, ? extends U> mapper;

        MapObserver(Observer<? super U> actual, Function<? super T, ? extends U> mapper) {
            // 把下游的Observer 保存在downstream 中
            super(actual);
            // 保存map 變換操作
            this.mapper = mapper;
        }

        // 本例中，onNext 是在emitter.onNext(1) 執行後，調用到這裏的
        @Override
        public void onNext(T t) {
            if (done) {
                return;
            }

            if (sourceMode != NONE) {
                downstream.onNext(null);
                return;
            }
			//目標類型
            U v;

            try {
                // 實現了變化操作，把t 轉爲 v 
                v = ObjectHelper.requireNonNull(mapper.apply(t), "The mapper function returned a null value.");
            } catch (Throwable ex) {
                fail(ex);
                return;
            }
            
            //調用了下游onNext，繼續分發數據，此時的數據是轉換後的目標數據
            downstream.onNext(v);
        }

        @Override
        public int requestFusion(int mode) {
            return transitiveBoundaryFusion(mode);
        }

        @Nullable
        @Override
        public U poll() throws Exception {
            T t = qd.poll();
            return t != null ? ObjectHelper.<U>requireNonNull(mapper.apply(t), "The mapper function returned a null value.") : null;
        }
    }
}

此時再去看看上面的圖，是不是有點感覺了，沒錯，全部都是這個套路，只是每次在裝飾的時候，行爲不一樣

subscribeOn操作符

作用是控制subscribe 的線程，下面來看看subscribeOn 是如何實現的

不仔細看代碼，還以爲作者直接把實現map的代碼拷貝了一份，簡直太相似了

    public final Observable<T> subscribeOn(Scheduler scheduler) {
        ObjectHelper.requireNonNull(scheduler, "scheduler is null");
        //使用原來的Observable 和調度線程，創建一個新的Observable，就是ObservableSubscribeOn
        return RxJavaPlugins.onAssembly(new ObservableSubscribeOn<T>(this, scheduler));
    }

依舊是創建新的Observable（ObservableSubscribeOn）和 Observer （SubscribeOnObserver）

public final class ObservableSubscribeOn<T> extends AbstractObservableWithUpstream<T, T> {
    final Scheduler scheduler;

    public ObservableSubscribeOn(ObservableSource<T> source, Scheduler scheduler) {
        // 依舊是保存了上游 ObservableSource
        super(source);
        // 保存了線程調度的Scheduler 
        this.scheduler = scheduler;
    }

    @Override
    public void subscribeActual(final Observer<? super T> observer) {
        // 使用裝飾着模式，把原來的Observer 封裝了一層
        final SubscribeOnObserver<T> parent = new SubscribeOnObserver<T>(observer);

		//注意，這裏還沒有切換新城，調用了onSubscribe
        observer.onSubscribe(parent);
		//這裏是重點，
		//scheduler.scheduleDirect(new SubscribeTask(parent))   在新線程中執行parent，
		//parent.setDisposable  把新線程任務，加入到DisposableHelper，如果手動dispose後，保證線程可以停止
        parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));
    }

    static final class SubscribeOnObserver<T> extends AtomicReference<Disposable> implements Observer<T>, Disposable {

        private static final long serialVersionUID = 8094547886072529208L;
        final Observer<? super T> downstream;

        final AtomicReference<Disposable> upstream;

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

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

       // 下面的常規操作方法，就是調用downstream  的各個操作方法
        @Override
        public void onNext(T t) {
            downstream.onNext(t);
        }

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

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

        @Override
        public void dispose() {
            DisposableHelper.dispose(upstream);
            DisposableHelper.dispose(this);
        }

        @Override
        public boolean isDisposed() {
            return DisposableHelper.isDisposed(get());
        }

        void setDisposable(Disposable d) {
           //把當前
            DisposableHelper.setOnce(this, d);
        }
    }

    // 實現了線程的Runnable 接口，目的是讓線程可以調度
    final class SubscribeTask implements Runnable {
        private final SubscribeOnObserver<T> parent;

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

        @Override
        public void run() {
            // 會在新的線程中調用，source是上游的Observable
            source.subscribe(parent);
        }
    }
}

截止到這裏，subscribeOn總體的邏輯已經，搞清楚了，再深入一點看一下scheduler.scheduleDirect(new SubscribeTask(parent)) 是如何實現線程切換的

    @NonNull
    public Disposable scheduleDirect(@NonNull Runnable run) {
        //調用scheduleDirect，參數表示立即執行
        return scheduleDirect(run, 0L, TimeUnit.NANOSECONDS);
    }

    @NonNull
    public Disposable scheduleDirect(@NonNull Runnable run, long delay, @NonNull TimeUnit unit) {
        //創建了一個worker，注意這裏的createWorker()，是一個抽象方法，不同的線程，創建的worker 不一樣。
        // 例如：Schedulers.io()  創建的是 EventLoopWorker
        final Worker w = createWorker();

        // 依舊是切面編程，對每個切換線程的， 包裹一層
        final Runnable decoratedRun = RxJavaPlugins.onSchedule(run);
		//把worker 和 Runnable  封裝成DisposeTask ，方便外界調用disposed，來停止它的運行
        DisposeTask task = new DisposeTask(decoratedRun, w);
		//立即開始執行
        w.schedule(task, delay, unit);

        return task;
    }

在深入看一下上面的DisposeTask，是如何封裝的。

這段代碼，我多說一句，你都會嫌我囉嗦

    static final class DisposeTask implements Disposable, Runnable, SchedulerRunnableIntrospection {

        @NonNull
        final Runnable decoratedRun;

        @NonNull
        final Worker w;

        @Nullable
        Thread runner;

        DisposeTask(@NonNull Runnable decoratedRun, @NonNull Worker w) {
            this.decoratedRun = decoratedRun;
            this.w = w;
        }

        @Override
        public void run() {
            runner = Thread.currentThread();
            try {
                decoratedRun.run();
            } finally {
                dispose();
                runner = null;
            }
        }

        @Override
        public void dispose() {
            if (runner == Thread.currentThread() && w instanceof NewThreadWorker) {
                ((NewThreadWorker)w).shutdown();
            } else {
                w.dispose();
            }
        }

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

        @Override
        public Runnable getWrappedRunnable() {
            return this.decoratedRun;
        }
    }

總結：

現在你再結合上圖來理解一下，是不是瞬間感覺，WC，這麼簡單的代碼，也有人寫博客發佈

懂了subscribeOn的源碼，那麼想想，大家經常討論的多個subscribeOn 調用，線程切換的問題，兩句話。

subscribeOn 對上游訂閱有效
最上面的subscribeOn 對發送數據有效

observeOn操作符

控制 onNext，onComplete 等數據消費方法的線程，

下面的分析略有差異，但總體和上面還是一樣的，你也可以自行read fuck source code ，相信你的印象會更加深刻

    public final Observable<T> observeOn(Scheduler scheduler) {
        //爲什麼這裏，有bufferSize()
        //這就是Rxjava 2 所添加背壓的概念，rxjava 1  會有一個問題，就是如果上游一直髮送數據onNext ，拼命的調用，
        // 但是onNext() 處理的不夠快，就會出現棧溢出。這個bufferSize 就是控制了，緩衝區的大小
        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");
        //重點ObservableObserveOn
        return RxJavaPlugins.onAssembly(new ObservableObserveOn<T>(this, scheduler, delayError, bufferSize));
    }

創建新的Observable （ObservableObserveOn）和 Observer（ObserveOnObserver）

public final class ObservableObserveOn<T> extends AbstractObservableWithUpstream<T, T> {
    final Scheduler scheduler;
    final boolean delayError;
    final int bufferSize;
    public ObservableObserveOn(ObservableSource<T> source, Scheduler scheduler, boolean delayError, int bufferSize) {
        //保存上游Observable 
        super(source);
        //保存調度線程
        this.scheduler = scheduler;
        //
        this.delayError = delayError;
        //緩衝區
        this.bufferSize = bufferSize;
    }

    @Override
    protected void subscribeActual(Observer<? super T> observer) {
        //TrampolineScheduler 官方文檔的解釋  * Schedules work on the current thread but does not execute immediately. Work is put in a queue and executed after the current unit of work is completed.
        if (scheduler instanceof TrampolineScheduler) {
            source.subscribe(observer);
        } else {
            // 創建一個worker，線程的調度就是在這裏
            Scheduler.Worker w = scheduler.createWorker();
			// 因爲observeOn 是控制處理數據的線程，所以在訂閱的時候，不去切換線程
			// 把線程worker，緩衝區，下游observer  都都封裝進ObserveOnObserver ，等到onSubscribe，onNext 調用到來是，在去切換線程去處理
            source.subscribe(new ObserveOnObserver<T>(observer, w, delayError, bufferSize));
        }
    }
    
     ...   省略 ObserveOnObserver 代碼 ...
}

上面關於 TrampolineScheduler 可以查看這篇文章

下面來看一下 ObserveOnObserver

    static final class ObserveOnObserver<T> extends BasicIntQueueDisposable<T>
    implements Observer<T>, Runnable {

        private static final long serialVersionUID = 6576896619930983584L;
        final Observer<? super T> downstream;
        final Scheduler.Worker worker;
        final boolean delayError;
        final int bufferSize;

        SimpleQueue<T> queue;

        Disposable upstream;

        Throwable error;
        volatile boolean done;

        volatile boolean disposed;

        int sourceMode;

        boolean outputFused;

        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 onSubscribe(Disposable d) {
            if (DisposableHelper.validate(this.upstream, d)) {
                this.upstream = d;
				// 上游的Observer 被封裝成了QueueDisposable，那麼使用這裏面的sourceMode ，queue  等信息
                if (d instanceof QueueDisposable) {
                    @SuppressWarnings("unchecked")
                    QueueDisposable<T> qd = (QueueDisposable<T>) d;

                    int m = qd.requestFusion(QueueDisposable.ANY | QueueDisposable.BOUNDARY);

                    if (m == QueueDisposable.SYNC) {
                        sourceMode = m;
                        queue = qd;
                        done = true;
                        downstream.onSubscribe(this);
                        schedule();
                        return;
                    }
                    if (m == QueueDisposable.ASYNC) {
                        sourceMode = m;
                        queue = qd;
                        downstream.onSubscribe(this);
                        return;
                    }
                }
				//大多數情況會到這裏創建一個隊列，使用指定的緩衝區
                queue = new SpscLinkedArrayQueue<T>(bufferSize);

                downstream.onSubscribe(this);
            }
        }

        @Override
        public void onNext(T t) {
            //執行過error / complete 會是true
            if (done) {
                return;
            }
			//如果不是異步的，就把數據放到隊列中
            if (sourceMode != QueueDisposable.ASYNC) {
                queue.offer(t);
            }
            //開始執行
            schedule();
        }

        @Override
        public void onError(Throwable t) {
            if (done) {
                RxJavaPlugins.onError(t);
                return;
            }
            error = t;
            done = true;
            schedule();
        }

        @Override
        public void onComplete() {
            if (done) {
                return;
            }
            done = true;
            schedule();
        }

        @Override
        public void dispose() {
            if (!disposed) {
                // 結束運行
                disposed = true;
                upstream.dispose();
                worker.dispose();
                if (getAndIncrement() == 0) {
                    queue.clear();
                }
            }
        }

        @Override
        public boolean isDisposed() {
            return disposed;
        }

        void schedule() {
            //該類繼承了，AtomicInteger，多線程下保證worker值開啓一個線程
            //有可能調用onNext 是在不同的線程
            if (getAndIncrement() == 0) {
                // this 是一個Runable 接口，在新線程中執行
                worker.schedule(this);
            }
        }

        void drainNormal() {
            int missed = 1;

            final SimpleQueue<T> q = queue;
            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;
                    }
					//發送數據給下游
                    a.onNext(v);
                }

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

        void drainFused() {
            int missed = 1;

            for (;;) {
                if (disposed) {
                    return;
                }

                boolean d = done;
                Throwable ex = error;

                if (!delayError && d && ex != null) {
                    disposed = true;
                    downstream.onError(error);
                    worker.dispose();
                    return;
                }

                downstream.onNext(null);

                if (d) {
                    disposed = true;
                    ex = error;
                    if (ex != null) {
                        downstream.onError(ex);
                    } else {
                        downstream.onComplete();
                    }
                    worker.dispose();
                    return;
                }

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

		//上面work.schedule(this) 後，會執行這裏
        @Override
        public void run() {
            if (outputFused) {
                //這裏是有關背壓的，暫時先不講解
                drainFused();
            } else {
                drainNormal();
            }
        }

        boolean checkTerminated(boolean d, boolean empty, Observer<? super T> a) {
            if (disposed) {
                queue.clear();
                return true;
            }
            // 是否已經完成
            if (d) {
                Throwable e = error;
                //是否分發Error
                if (delayError) {
                   //隊列是否爲空
                    if (empty) {
                        disposed = true;
                        //是否有錯誤信息
                        if (e != null) {
                            a.onError(e);
                        } else {
                            a.onComplete();
                        }
                        worker.dispose();
                        return true;
                    }
                } else {
                    if (e != null) {
                        disposed = true;
                        queue.clear();
                        a.onError(e);
                        worker.dispose();
                        return true;
                    } else
                    if (empty) {
                        disposed = true;
                        a.onComplete();
                        worker.dispose();
                        return true;
                    }
                }
            }
            return false;
        }

        @Override
        public int requestFusion(int mode) {
           // 這部分也與背壓有關，暫時不展開
            if ((mode & ASYNC) != 0) {
                outputFused = true;
                return ASYNC;
            }
            return NONE;
        }

        @Nullable
        @Override
        public T poll() throws Exception {
            return queue.poll();
        }

        @Override
        public void clear() {
            queue.clear();
        }

        @Override
        public boolean isEmpty() {
            return queue.isEmpty();
        }
    }
}

總結：

到這裏應該對observeOn 也一定的瞭解，多個observeOn 嵌套的問題，一句話，只對下游的Observer有效。再結合上圖的流程，subscribeOn 和 observeOn 胡亂嵌套，都能理清楚了。

RxJava之七——RxJava 2.0 圖文分析create()、 subscribe()、map()、observeOn()、subscribeOn()源碼

前言

示例

基本流程

create

subscribe

map操作符

subscribeOn操作符

observeOn操作符

引用其他project的module，根據參數自動配置依賴，repo管理多個 Project

Android 在動畫結束回調onAnimationEnd()中remove view的崩潰解決方法及源碼分析

Fragment.setNextAnim(int) on a null object 解決方法及源碼詳解

記錄我修改JakeWharton的ButterKnife bug的實戰經驗

Android View 的scroll相關方法屬性以及Scroller彈性滑動原理

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結