商業轉載請聯繫作者獲得授權，非商業轉載請註明出處。

一 Rxjava3簡介

ReactiveX的歷史

ReactiveX是Reactive Extensions的縮寫，一般簡寫爲Rx，最初是LINQ的一個擴展，由微軟的架構師Erik Meijer領導的團隊開發，在2012年11月開源，Rx是一個編程模型，目標是提供一致的編程接口，幫助開發者更方便的處理異步數據流，Rx近幾年越來越流行了，現在已經支持幾乎全部的流行編程語言了，Rx的大部分語言庫由ReactiveX這個組織負責維護，比較流行的有RxJava/RxJS/Rx.NET，社區網站是 reactivex.io。

什麼是ReactiveX

微軟給的定義是，Rx是一個函數庫，讓開發者可以利用可觀察序列和LINQ風格查詢操作符來編寫異步和基於事件的程序，使用Rx，開發者可以用Observables表示異步數據流，用LINQ操作符查詢異步數據流，用Schedulers參數化異步數據流的併發處理，Rx可以這樣定義：Rx = Observables + LINQ + Schedulers。

ReactiveX.io給的定義是，Rx是一個使用可觀察數據流進行異步編程的編程接口，ReactiveX結合了觀察者模式、迭代器模式和函數式編程的精華。

Observable擁有它的近親Iterable的全部優雅與靈活。任何對Iterable的操作，你都可以對Observable使用。

RxJava

RxJava是響應式編程(Reactive Extensions)的java實現，它基於觀察者模式的實現了異步編程接口。

Rxjava 3.x 的github官網；

RxJava2將被支持到2021年2月28日，錯誤的會同時在2.x和3.x修復，但新功能只會在3.x上添加；

Rxjava 3.0的一些改變：官方Wiki；

Rxjava 3.x 文檔可以在官方javadoc中找到；

使用Rxjava3.x之前的準備工作：

添加依賴

    //RxJava的依賴包
    implementation 'io.reactivex.rxjava3:rxandroid:3.0.0'
    //RxAndroid的依賴包  
    implementation 'io.reactivex.rxjava3:rxjava:3.0.0'

RxJava 在很長一段時間裏以java6 爲baseline（ Android 運行時支持的鍋），但在即將到來的 Android Studio 4預覽中，一個叫做 desuging 的過程能夠將許多 Java 7和8的特性，透明地轉換成與 Java 6兼容的特性。因此我們可以將 RxJava 的基準提高到 java 8，併爲許多 Java 8構造增加官方支持比如：Optional、Stream等，因此必須將項目的編譯目標設置更改爲 java8:

android {
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }
}

二 Rx中的一些概念

2.1 字段含義

Reactive 直譯爲反應性的，有活性的，根據上下文一般翻譯爲反應式、響應式
Iterable 可迭代對象，支持以迭代器的形式遍歷，許多語言中都存在這個概念
Observable 可觀察對象，在Rx中定義爲更強大的Iterable，在觀察者模式中是被觀察的對象，一旦數據產生或發生變化，會通過某種方式通知觀察者或訂閱者
Observer 觀察者對象，監聽Observable發射的數據並做出響應，Subscriber是它的一個特殊實現
emit 直譯爲發射，發佈，發出，含義是Observable在數據產生或變化時發送通知給Observer，調用Observer對應的方法，文章裏一律譯爲發射
items 直譯爲項目，條目，在Rx裏是指Observable發射的數據項，文章裏一律譯爲數據，數據項。

2.2 上/下流

在RxJava中，數據以流的方式組織：Rxjava包括一個源數據流，源數據流後跟着若干個用於消費數據流的步驟。

source
  .operator1()
  .operator2()
  .operator3()
  .subscribe(consumer)

在代碼中，對於operator2來說，在它前面叫做上流，在它後面的叫做下流。

2.3 流對象

在RxJava的文檔中，emission, emits, item, event, signal, data and message都被認爲在數據流中被傳遞的數據對象。

2.4 背壓(Backpressure)

當上下游在不同的線程中，通過Observable發射，處理，響應數據流時，如果上游發射數據的速度快於下游接收處理數據的速度，這樣對於那些沒來得及處理的數據就會造成積壓，這些數據既不會丟失，也不會被垃圾回收機制回收，而是存放在一個異步緩存池中，如果緩存池中的數據一直得不到處理，越積越多，最後就會造成內存溢出，這便是響應式編程中的背壓（backpressure）問題。

爲此，RxJava帶來了backpressure的概念。背壓是一種流量的控制步驟，在不知道上流還有多少數據的情形下控制內存的使用，表示它們還能處理多少數據。背壓是指在異步場景中，被觀察者發送事件速度遠快於觀察者的處理速度的情況下，一種告訴上游的被觀察者降低發送速度的策略

在Rxjava1.0中，有的Observable支持背壓，有的不支持，爲了解決這種問題，2.0把支持背壓和不支持背壓的Observable區分開來：支持背壓的有Flowable類，不支持背壓的有Observable，Single, Maybe and Completable類。

在訂閱的時候如果使用FlowableSubscriber，那麼需要通過s.request(Long.MAX_VALUE)去主動請求上游的數據項。如果遇到背壓報錯的時候，FlowableSubscriber默認已經將錯誤try-catch，並通過onError()進行回調，程序並不會崩潰；
在訂閱的時候如果使用Consumer，那麼不需要主動去請求上游數據，默認已經調用了s.request(Long.MAX_VALUE)。如果遇到背壓報錯、且對Throwable的Consumer沒有new出來，則程序直接崩潰；
背壓策略的上游的默認緩存池是128。

背壓策略：

error，緩衝區大概在128
buffer，緩衝區在1000左右
drop，把存不下的事件丟棄
latest，只保留最新的
missing, 缺省設置，不做任何操作

public enum BackpressureStrategy {
    /**
     * OnNext events are written without any buffering or dropping.
     * Downstream has to deal with any overflow.
     * <p>Useful when one applies one of the custom-parameter onBackpressureXXX operators.
     */
    MISSING,
    /**
     * Signals a MissingBackpressureException in case the downstream can't keep up.
     */
    ERROR,
    /**
     * Buffers <em>all</em> onNext values until the downstream consumes it.
     */
    BUFFER,
    /**
     * Drops the most recent onNext value if the downstream can't keep up.
     */
    DROP,
    /**
     * Keeps only the latest onNext value, overwriting any previous value if the
     * downstream can't keep up.
     */
    LATEST
}

2.5 線程調度器（Schedulers）

對於Android開發者而言，RxJava最簡單的是通過調度器來方便地切換線程。在不同平臺還有不同的調度器，例如我們Android的主線程：AndroidSchedulers.mainThread()。

調度器	功能
AndroidSchedulers.mainThread()	需要引用rxandroid, 切換到UI線程
Schedulers.computation()	用於計算任務，如事件循環和回調處理，默認線程數等於處理器數量
Schedulers.io()	用於IO密集型任務，如異步阻塞IO操作，這個調度器的線程池會根據需求，它默認是一個CacheThreadScheduler
Schedulers.newThread()	爲每一個任務創建一個新線程
Schedulers.trampoline()	在當前線程中立刻執行，如當前線程中有任務在執行則將其暫停，等插入進來的任務執行完成之後，在將未完成的任務繼續完成。
Scheduler.from(executor)	指定Executor作爲調度器

2.6 事件調度器

RxJava事件發出去並不是置之不顧，要有合理的管理者來管理它們，在合適的時機要進行釋放事件，這樣纔不會導致內存泄漏，這裏的管理者我們稱爲事件調度器(或事件管理者)CompositeDisposable。

2.7 基類

RxJava 3 中的基類相比RxJava 2 沒啥改變，主要有以下幾個基類：

io.reactivex.Flowable：發送0個N個的數據，支持Reactive-Streams和背壓
io.reactivex.Observable：發送0個N個的數據，不支持背壓，
io.reactivex.Single：只能發送單個數據或者一個錯誤
io.reactivex.Completable：沒有發送任何數據，但只處理 onComplete 和 onError 事件。
io.reactivex.Maybe：能夠發射0或者1個數據，要麼成功，要麼失敗。

2.8 Observables的"熱"和"冷"

Observable什麼時候開始發射數據序列？這取決於Observable的實現，一個"熱"的Observable可能一創建完就開始發射數據，因此所有後續訂閱它的觀察者可能從序列中間的某個位置開始接受數據（有一些數據錯過了）。一個"冷"的Observable會一直等待，直到有觀察者訂閱它纔開始發射數據，因此這個觀察者可以確保會收到整個數據序列。

在一些ReactiveX實現裏，還存在一種被稱作Connectable的Observable，不管有沒有觀察者訂閱它，這種Observable都不會開始發射數據，除非Connect方法被調用。

三 RxJava的簡單使用

需要知道的是，RxJava以觀察者模式爲骨架，有兩種常見的觀察者模式：

Observable(被觀察者)/Observer（觀察者）
Flowable(被觀察者)/Subscriber(觀察者)

RxJava2/3中，Observeable用於訂閱Observer，是不支持背壓的，而Flowable用於訂閱Subscriber，是支持背壓(Backpressure)的。

3.1 Observable/Observer

Observable正常用法：

          Observable mObservable=Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                e.onNext(1);
                e.onNext(2);
                e.onComplete();
            }
        });

        Observer mObserver=new Observer<Integer>() {
            //這是新加入的方法，在訂閱後發送數據之前，
            //回首先調用這個方法，而Disposable可用於取消訂閱
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(Integer value) {
                Log.e("lucas", "onNext: "+value );
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        };

        mObservable.subscribe(mObserver);

這種觀察者模型不支持背壓：當被觀察者快速發送大量數據時，下游不會做其他處理，即使數據大量堆積，調用鏈也不會報MissingBackpressureException,消耗內存過大隻會OOM。所以，當我們使用Observable/Observer的時候，我們需要考慮的是，數據量是不是很大(官方給出以1000個事件爲分界線作爲參考)。

3.2 Flowable/Subscriber

        Flowable.range(0,10)
        .subscribe(new Subscriber<Integer>() {
            Subscription sub;
            //當訂閱後，會首先調用這個方法，其實就相當於onStart()，
            //傳入的Subscription s參數可以用於請求數據或者取消訂閱
            @Override
            public void onSubscribe(Subscription s) {
                Log.w("TAG","onsubscribe start");
                sub=s;
                sub.request(1);
                Log.w("TAG","onsubscribe end");
            }

            @Override
            public void onNext(Integer o) {
                Log.w("TAG","onNext--->"+o);
                sub.request(1);
            }
            @Override
            public void onError(Throwable t) {
                t.printStackTrace();
            }
            @Override
            public void onComplete() {
                Log.w("TAG","onComplete");
            }
        });

輸出如下：

onsubscribe start
onNext--->0
onNext--->1
onNext--->2
...
onNext--->9
onComplete
onsubscribe end

Flowable是支持背壓的，也就是說，一般而言，上游的被觀察者會響應下游觀察者的數據請求，下游調用request(n)來告訴上游發送多少個數據。這樣避免了大量數據堆積在調用鏈上，使內存一直處於較低水平。

當然，Flowable也可以通過creat()來創建：

        Flowable.create(new FlowableOnSubscribe<Integer>() {
            @Override
            public void subscribe(FlowableEmitter<Integer> e) throws Exception {
                e.onNext(1);
                e.onNext(2);
                e.onNext(3);
                e.onNext(4);
                e.onComplete();
            }
        }
        //需要指定背壓策略
        , BackpressureStrategy.BUFFER);

Flowable雖然可以通過create()來創建，但是你必須指定背壓的策略，以保證你創建的Flowable是支持背壓的。

根據上面的代碼的結果輸出中可以看到，當我們調用subscription.request(n)方法的時候，不等onSubscribe()中後面的代碼執行，就會立刻執行到onNext方法，因此，如果你在onNext方法中使用到需要初始化的類時，應當儘量在subscription.request(n)這個方法調用之前做好初始化的工作;

當然，這也不是絕對的，我在測試的時候發現，通過create（）自定義Flowable的時候，即使調用了subscription.request(n)方法，也會等onSubscribe（）方法中後面的代碼都執行完之後，纔開始調用onNext。

TIPS: 儘可能確保在request（）之前已經完成了所有的初始化工作，否則就有空指針的風險。

3.3 其他的觀察者

最常用的其實就是上面說的兩種訂閱觀察者，但是一些情況下，我們也會用到一些其他的一類觀察者比如

Single/SingleObserver
Completable/CompletableObserver
Maybe/MaybeObserver

3.3.1 Single/SingleObserver

Single類似於Observable，不同的是，它總是隻發射一個值，或者一個錯誤通知，而不是發射一系列的值（當然就不存在背壓問題），所以當你使用一個單一連續事件流，這樣你可以使用Single。Single觀察者只包含兩個事件，一個是正常處理成功的onSuccess，另一個是處理失敗的onError。因此，不同於Observable需要三個方法onNext, onError, onCompleted，訂閱Single只需要兩個方法：

onSuccess - Single發射單個的值到這個方法
onError - 如果無法發射需要的值，Single發射一個Throwable對象到這個方法

Single只會調用這兩個方法中的一個，而且只會調用一次，調用了任何一個方法之後，訂閱關係終止。

Single的操作符：

Single也可以組合使用多種操作，一些操作符讓你可以混合使用Observable和Single：

操作符	返回值	說明
compose	Single	創建一個自定義的操作符
concat and concatWith	Observable	連接多個Single和Observable發射的數據
create	Single	調用觀察者的create方法創建一個Single
error	Single	返回一個立即給訂閱者發射錯誤通知的Single
flatMap	Single	返回一個Single，它發射對原Single的數據執行flatMap操作後的結果
flatMapObservable	Observable	返回一個Observable，它發射對原Single的數據執行flatMap操作後的結果
from	Single	將Future轉換成Single
just	Single	返回一個發射一個指定值的Single
map	Single	返回一個Single，它發射對原Single的數據執行map操作後的結果
merge	Single	將一個Single(它發射的數據是另一個Single，假設爲B)轉換成另一個Single(它發射來自另一個Single(B)的數據)
merge and mergeWith	Observable	合併發射來自多個Single的數據
observeOn	Single	指示Single在指定的調度程序上調用訂閱者的方法
onErrorReturn	Single	將一個發射錯誤通知的Single轉換成一個發射指定數據項的Single
subscribeOn	Single	指示Single在指定的調度程序上執行操作
timeout	Single	它給原有的Single添加超時控制，如果超時了就發射一個錯誤通知
toSingle	Single	將一個發射單個值的Observable轉換爲一個Single
zip and zipWith	Single	將多個Single轉換爲一個，後者發射的數據是對前者應用一個函數後的結果

操作符詳細的圖解可以參考英文文檔：Single

        //被觀察者
        Single<String> single = Single.create(new SingleOnSubscribe<String>() {
            @Override
            public void subscribe(SingleEmitter<String> e) throws Exception {
                e.onSuccess("test");
                e.onSuccess("test2");//錯誤寫法，重複調用也不會處理，因爲只會調用一次
            }
        });

        //訂閱觀察者SingleObserver
        single.subscribe(new SingleObserver<String>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onSuccess(String s) {
                //相當於onNext和onComplete
                Log.d("lucas",  s  );
            }

            @Override
            public void onError(Throwable e) {

            }
        });

//運行結果
2020-04-03 23:02:37.337 15462-15462/com.ysalliance.getfan.myapplication D/lucas: test

3.3.2 Completable/CompletableObserver

如果你的觀察者連onNext事件都不關心，可以使用Completable，它只有onComplete和onError兩個事件：


        Completable.create(new CompletableOnSubscribe() {//被觀察者

            @Override
            public void subscribe(CompletableEmitter e) throws Exception {
                e.onComplete();//單一onComplete或者onError
            }

        }).subscribe(new CompletableObserver() {//觀察者
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onComplete() {
                Log.e("lucas", "onComplete: ");
            }

            @Override
            public void onError(Throwable e) {

            }
        });

//打印結果
2020-04-03 23:12:08.099 16264-16264/com.ysalliance.getfan.myapplication E/lucas: onComplete:

要轉換成其他類型的被觀察者，也是可以使用toFlowable()、toObservable()等方法去轉換。

3.3.3 Maybe/MaybeObserver

如果你有一個需求是可能發送一個數據或者不會發送任何數據，這時候你就需要Maybe，它類似於Single和Completable的混合體。

Maybe可能會調用以下其中一種情況（也就是所謂的Maybe）：

onSuccess或者onError
onComplete或者onError

可以看到onSuccess和onComplete是互斥的存在，例子代碼如下：

        //被觀察者
        Maybe<String> maybe = Maybe.create(new MaybeOnSubscribe<String>() {
            @Override
            public void subscribe(MaybeEmitter<String> e) throws Exception {
                e.onSuccess("test");//發送一個數據的情況，或者onError，不需要再調用onComplete(調用了也不會觸發onComplete回調方法)
                //e.onComplete();//不需要發送數據的情況，或者onError
            }
        });

        //訂閱觀察者
        maybe.subscribe(new MaybeObserver<String>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onSuccess(String s) {
                //發送一個數據時，相當於onNext和onComplete，但不會觸發另一個方法onComplete
                Log.i("lucas", s);
            }

            @Override
            public void onComplete() {
                //無數據發送時候的onComplete事件
                Log.i("lucas", "onComplete");
            }

            @Override
            public void onError(Throwable e) {

            }
        });

//打印結果
2020-04-03 23:14:40.266 16558-16558/com.ysalliance.getfan.myapplication I/lucas: test

要轉換成其他類型的被觀察者，也是可以使用toFlowable()、toObservable()等方法去轉換。

//判斷是否登陸
Maybe.just(isLogin())
    //可能涉及到IO操作，放在子線程
    .subscribeOn(Schedulers.newThread())
    //取回結果傳到主線程
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe(new MaybeObserver<Boolean>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onSuccess(Boolean value) {
                if(value){
                    ...
                }else{
                    ...
                }
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });複製代碼

上面就是Maybe/MaybeObserver的普通用法，你可以看到，實際上，這種觀察者模式並不用於發送大量數據，而是發送單個數據，也就是說，當你只想要某個事件的結果（true or false)的時候，你可以用這種觀察者模式

3.4 事件調度器釋放事件

public class Main {

    private static CompositeDisposable mRxEvent = new CompositeDisposable();

    public static void main(String[] args) {
        Disposable subscribe = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<String> e) throws Exception {
                e.onNext("俊俊俊很帥");
                e.onNext("你值得擁有");
                e.onNext("取消關注");
                e.onNext("但還是要保持微笑");
                e.onComplete();
            }
        }).subscribe(
                new Consumer<String>() {
                    @Override
                    public void accept(@NonNull String s) throws Exception {
                        //對應onNext()
                        System.out.println("accept=" + s);
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(@NonNull Throwable throwable) throws Exception {
                        //對應onError()
                    }
                }, new Action() {
                    @Override
                    public void run() throws Exception {
                        //對應onComplete()
                    }
                }, new Consumer<Disposable>() {
                    @Override
                    public void accept(@NonNull Disposable disposable) throws Exception {
                        //對應onSubscribe()
                    }
                });
        
        mRxEvent.add(subscribe);
        mRxEvent.clear();
    }
}

CompositeDisposable提供的方法中，都是對事件的管理

dispose():釋放所有事件
clear():釋放所有事件，實現同dispose()
add():增加某個事件
addAll():增加所有事件
remove():移除某個事件並釋放
delete():移除某個事件

3.5 小結

這是上面那些基類被觀察者的上層接口：

//Observable接口
interface ObservableSource<T> {
    void subscribe(Observer<? super T> observer);
}
//Single接口
interface SingleSource<T> {
    void subscribe(SingleObserver<? super T> observer);
}
//Completable接口
interface CompletableSource {
    void subscribe(CompletableObserver observer);
}
//Maybe接口
interface MaybeSource<T> {
    void subscribe(MaybeObserver<? super T> observer);
}
//Flowable接口
public interface Publisher<T> {
    public void subscribe(Subscriber<? super T> s);
}

其實我們可以看到，每一種觀察者都繼承自各自的接口，這也就把他們能完全的區分開，各自獨立（特別是Observable和Flowable）,保證了他們各自的拓展或者配套的操作符不會相互影響。

例如flatMap操作符實現：

//Flowable中flatMap的定義
Flowable<R> flatMap(Function<? super T, ? extends Publisher<? extends R>> mapper);

//Observable中flatMap的定義
Observable<R> flatMap(Function<? super T, ? extends ObservableSource<? extends R>> mapper);

假如你想爲Flowable寫一個自定義的操作符，那麼只要保證Function< Publisher >中的類型實現了Publisher接口即可。這麼說可能很抽象，大家不理解其實也沒關係，因爲並不推薦大家自定義操作符，RxJava中的操縱符的組合已經可以滿足大家的需求了。

當然，你也會注意到上面那些接口中的subscribe（）方法的返回類型爲void了，在1.X中，這個方法一般會返回一個Subscription對象，用於取消訂閱。現在，這個功能的對象已經被放到觀察者Observer或者subscriber的內部實現方法中了，

Flowable/Subscriber

public interface Subscriber<T> {  
    public void onSubscribe(Subscription s);
    public void onNext(T t);
    public void onError(Throwable t);
    public void onComplete();
}

public interface Subscription {
    public void request(long n);
    public void cancel();
}複製代碼

上面的實例中，onSubscribe(Subscription s)傳入的參數s就肩負着取消訂閱的功能，當然，他也可以用於請求上游的數據。

在Observable/observer中，傳入的參數是另一個對象

Observable/Observer

public interface Observer<T> {
   void onSubscribe(Disposable d);
    void onNext(T value);
    void onError(Throwable e);
    void onComplete();
}

public interface Disposable {
    /**
     * Dispose the resource, the operation should be idempotent.
     */
    void dispose();
    /**
     * Returns true if this resource has been disposed.
     * @return true if this resource has been disposed
     */
    boolean isDisposed();
}複製代碼

在Observer接口中，onSubscribe(Disposable d)方法傳入的Disposable也是用於取消訂閱，基本功能是差不多的，只不過命名不一致，大家知道就好。

其實這種設計可以說還是符合邏輯的，因爲取消訂閱這個動作就只有觀察者（Observer等）才能做的，現在把它併入到觀察者內部，也算順理成章吧。

Rxjava中，被觀察者不能接收null作爲數據源。

補充 1 Rxjava 3.x 主要更新內容如下API changes：

將eagerTruncate添加到replay運算符，以便head節點將在截斷時丟失它保留的項引用 (#6532)
新增 X.fromSupplier() (#6529)
使用 Scheduler 添加 concatMap，保證 mapper 函數的運行位置 (#6538)
新增 startWithItem 和 startWithIterable (#6530)
ConnectableFlowable/ConnetableFlowable 重新設計 (#6519)
將 as() 併入 to() (#6514)
更改 Maybe.defaultIfEmpty() 以返回 Single (#6517)
用 Supplier 代替 Callable (#6511)
將一些實驗操作符推廣到標準 (#6537)
從某些主題/處理器中刪除 getValues() (#6516)
刪除 replay(Scheduler) 及其重載 (#6539)
刪除 dematerialize() (#6539)
刪除 startWith(T|Iterable) (#6530)
刪除 as() (#6514)
刪除 Maybe.toSingle(T) (#6517)
刪除 Flowable.subscribe(4 args) (#6517)
刪除 Observable.subscribe(4 args) (#6517)
刪除 Single.toCompletable() (#6517)
刪除 Completable.blockingGet() (#6517)

參考文章：

因爲寫RxJava系列的文章時進行了很多閱讀和參考，因此不分一二三等，將全系列的參考引用統一如下：

RxJava3 Wiki：https://github.com/ReactiveX/RxJava/wiki

RxJava3官方github：https://github.com/ReactiveX/RxJava/wiki/What's-different-in-3.0

ReactiveX文檔中文翻譯：https://mcxiaoke.gitbooks.io/rxdocs/content/operators/Creating-Observables.html

single：http://reactivex.io/documentation/single.html

操作符系列講的很好的文章：https://blog.csdn.net/weixin_42046829/article/details/104836592

基礎介紹：https://blog.csdn.net/weixin_42046829/article/details/104833751

RxJava3的一些簡介：https://juejin.im/post/5d1eeffe6fb9a07f0870b4e8

觀察者被觀察者入門RxJava的一篇好文章：https://juejin.im/post/580103f20e3dd90057fc3e6d

關於背壓一個很好的介紹：https://juejin.im/post/582d413c8ac24700619cceed

RxLifecycle：https://github.com/trello/RxLifecycle

剛哥平臺的挺好很全：RxJava2 只看這一篇文章就夠了https://juejin.im/post/5b17560e6fb9a01e2862246f

Rxjava3文檔級教程一：介紹和基本使用

一 Rxjava3簡介

ReactiveX的歷史

什麼是ReactiveX

RxJava

二 Rx中的一些概念

2.1 字段含義

2.2 上/下流

2.3 流對象

2.4 背壓(Backpressure)

2.5 線程調度器（Schedulers）

2.6 事件調度器

2.7 基類

2.8 Observables的"熱"和"冷"

三 RxJava的簡單使用

3.1 Observable/Observer

3.2 Flowable/Subscriber

3.3 其他的觀察者

3.3.1 Single/SingleObserver

3.3.2 Completable/CompletableObserver

3.3.3 Maybe/MaybeObserver

3.4 事件調度器釋放事件

3.5 小結

補充 1 Rxjava 3.x 主要更新內容如下API changes：

參考文章：

關於遊戲付費的一點想法

我通過CKA和CKS啦！

Linux服務器性能參數相關信息之Top命令詳解

Android 最穩定和高效的UI適配方案總結

由前後端數據處理分配引發的一些思考

DRF-Django Rest frameWork脈絡筆記

Django Error:1452, 'Cannot add or update a child row: a foreign key constraint fails

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

linux以太網驅動總結

Rxjava3文檔級教程一： 介紹和基本使用

一 Rxjava3簡介

ReactiveX的歷史

什麼是ReactiveX

RxJava

二 Rx中的一些概念

2.1 字段含義

2.2 上/下流

2.3 流對象

2.4 背壓(Backpressure)

2.5 線程調度器（Schedulers）

2.6 事件調度器

2.7 基類

2.8 Observables的"熱"和"冷"

三 RxJava的簡單使用

3.1 Observable/Observer

3.2 Flowable/Subscriber

3.3 其他的觀察者

3.3.1 Single/SingleObserver

3.3.2 Completable/CompletableObserver

3.3.3 Maybe/MaybeObserver

3.4 事件調度器釋放事件

3.5 小結

補充 1 Rxjava 3.x 主要更新內容如下API changes：

參考文章：

Rxjava3文檔級教程一：介紹和基本使用