Rxjava2(二)、五種觀察者模式創建及背壓

Android進階系列之第三方庫知識點整理。

知識點總結，整理也是學習的過程，如有錯誤，歡迎批評指出。

上一篇：Rxjava2(一)、基礎概念及使用

直接開整，上一篇基礎概念裏面說了，rxjava2 擴展於觀察者模式，我們上篇的只是簡單的介紹了用Observable來創建使用，其實rxjava2給我們提供了五種觀察者模式的創建方式。

1、Observable 和 Observer

能夠發射0或n個數據，並以成功或錯誤事件終止，在第一篇中已經舉例說明了，這裏就不再詳細說明。

2、Flowable 和 Subscriber

能夠發射0或n個數據，並以成功或錯誤事件終止。支持背壓，可以控制數據源發射的速度。

我們看到Observable和Flowable這兩個的區別就是後者支持背壓，那麼何爲背壓？

2.1、什麼是背壓

背壓是一種現象，簡單來說就是在異步操作中，上游發送數據速度快於下游處理數據的速度，下游來不及處理，Buffer 溢出，導致事件阻塞，從而引起的各種問題，比如事件丟失，OOM等。

在rxjava1中並不支持背壓，當出現事件阻塞時候，會直接拋出 MissingBackpressureException 異常，但是在rxjava2中，提供了 Flowable 來創建被觀察者，通過Flowable 來處理背壓問題，我們可以簡單通過demo分析。

[站外圖片上傳中...(image-7e5758-1577706002259)]

A：我們上游模擬循環發送數據。

B：線程切換，異步操作。

C：下游每隔一秒獲取數據。

我們Observable 創建，來模擬了背壓這個現象，我們在上游模擬無限循環的發送數據，下游每次都休眠一秒再獲取數據，這樣肯定會造成我們前面提的問題，就是上游發送太他丫的快了，下游根本處理不過來，我們先看結果。

看日誌，打印結果停留在了13就沒有繼續打印了？同時可以看到程序已經崩了，是因爲在rxjava2中，Observable並不支持背壓操作，遇到背壓問題，它並不會報錯，也不會拋MissingBackpressureException 異常，但是內存會一直飆高，最後導致內存不足程序直接掛掉。

[站外圖片上傳中...(image-41c5f6-1577706002259)]

可以看到內存一直在往上飆，針對背壓這種現象，rxjava2中提出用 Flowable 來處理。

下面由淺入深，慢慢揭開Flowable 的神祕面紗。

我們先用Flowable創建一個基本的demo：

       Flowable.create(new FlowableOnSubscribe<String>() {
            @Override
            public void subscribe(FlowableEmitter<String> emitter) throws Exception {
                emitter.onNext("事件一");
                LogUtil.d(TAG + "--subscribe  發送事件一");
                emitter.onNext("事件二");
                LogUtil.d(TAG + "--subscribe  發送事件二");
                emitter.onNext("事件三");
                LogUtil.d(TAG + "--subscribe  發送事件三");
                emitter.onNext("事件四");
                LogUtil.d(TAG + "--subscribe  發送事件四");
                emitter.onComplete();
                LogUtil.d(TAG + "--subscribe  發送完成");
            }
        }, BackpressureStrategy.ERROR) // 這裏需要傳入背壓策略，跟線程池裏面飽和策略類似，當緩存區存滿時候採取的處理策略
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread()) // 線程切換，異步操作
                .subscribe(new Subscriber<String>() {
                    @Override
                    public void onSubscribe(Subscription s) {
                        LogUtil.d(TAG + "--onSubscribe");
                        // 決定觀察者能接收多少個事件，多餘事件放入緩存區
                        // Flowable 默認緩存區大小爲128，即最大能存放128個事件
                        s.request(3);
                    }

                    @Override
                    public void onNext(String s) {
                        LogUtil.d(TAG + "--onNext  接收到:" + s);
                    }

                    @Override
                    public void onError(Throwable t) {
                        LogUtil.d(TAG + "--onError  error=" + t.getLocalizedMessage());
                    }

                    @Override
                    public void onComplete() {
                        LogUtil.d(TAG + "--onComplete");
                    }
                });

可以看到Flowable創建和Observable基本差不多，只是在create方法中多傳入BackpressureStrategy.ERROR 這麼一個背壓策略，這個後面會詳講。

在 onSubscribe 的回調中，參數變成了Subscription，我們可以通過這個參數，讓觀察者自己設置要接收多少個事件，如果發送的事件大於觀察者設置接收的事件，多餘事件將會存入Flowable緩存區中。

Flowable緩存區隊列大小隻能存放128個事件，如果超過，就會報異常。

結果：

[站外圖片上傳中...(image-af462-1577706002259)]

發送四個事件，觀察者通過Subscription.request(3)設置只接收三個事件，所以下游只接收三個，剩下一個放入Flowable緩存區中。

如果我們觀察者不設置Subscription.request(x),即不接收事件，被觀察者仍然會發送事件，並存入緩存區中，觀察者可以動態調用Subscription.request(x)方法來獲取事件。

        Flowable.create(new FlowableOnSubscribe<String>() {
            @Override
            public void subscribe(FlowableEmitter<String> emitter) throws Exception {

                for (int x = 0; x <= 10; x++) {
                    LogUtil.d(TAG + "--subscribe  發送了" + x + "個事件");
                    emitter.onNext(x + "事件");
                }
            }
        }, BackpressureStrategy.ERROR) 
                // 線程切換，異步操作
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Subscriber<String>() {
                    @Override
                    public void onSubscribe(Subscription s) {
                        LogUtil.d(TAG + "--onSubscribe");
                        subscription = s;
                        // s.request(3);  這裏不指定觀察者接收事件個數
                    }

                    @Override
                    public void onNext(String s) {
                        LogUtil.d(TAG + "--onNext  接收到:" + s);
                    }

                    @Override
                    public void onError(Throwable t) {
                        LogUtil.d(TAG + "--onError  error=" + t.getLocalizedMessage());
                    }

                    @Override
                    public void onComplete() {
                        LogUtil.d(TAG + "--onComplete");
                    }
                });

動態獲取

findViewById(R.id.bt_get_event).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                if (subscription != null) {
                    LogUtil.d(TAG + "--onClick");
                    subscription.request(4);
                }
            }
        });

可以看到我們觀察者一開始並沒有指定接收多少個事件，而是通過外接點擊事件，來動態設置接收事件個數，我們看結果，當點擊觸發後，我們收到了最先存入隊列的四個事件。

結果：

2.2、背壓策略

我們前面提到，Flowable 默認的緩存區隊列大小爲128，即只能存放上游發送的128個事件，如果上游發送的事件超過128，就需要我們指定相應的背壓策略來做不同的處理，BackpressureStrategy爲我們提供了五種背壓策略。

[站外圖片上傳中...(image-287d84-1577706002259)]

整理如下：

策略	作用
MISSING	當緩存區大小存滿（128），被觀察者仍然繼續發送下一個事件時，拋出異常`MissingBackpressureException` , 提示緩存區滿了
ERROR	當緩存區大小存滿（128）（默認緩存區大小128），被觀察者仍然繼續發送下一個事件時，直接拋出異常`MissingBackpressureException`
BUFFER	當緩存區大小存滿（128），被觀察者仍然繼續發送下一個事件時，緩存區大小設置無限大, 即被觀察者可無限發送事件，但實際上是存放在緩存區
DROP	當緩存區大小存滿，被觀察者仍然繼續發送下一個事件時，超過緩存區大小（128）的事件會被全部丟棄
LATEST	當緩存區大小存滿，被觀察者仍然繼續發送下一個事件時，只保存最新/最後發送的事件，其他超過緩存區大小（128）的事件會被全部丟棄

2.2.1、BackpressureStrategy.MISSING

當緩存區大小存滿（128），被觀察者仍然繼續發送下一個事件時，拋出異常MissingBackpressureException , 提示緩存區滿了

        Flowable.create(new FlowableOnSubscribe<String>() {
            @Override
            public void subscribe(FlowableEmitter<String> emitter) throws Exception {
                // 發送129個事件，模擬超出緩存區
                for (int x = 0; x < 129; x++) {
                    emitter.onNext(x + "事件");
                    LogUtil.d(TAG + "--subscribe  發送了" + x + "個事件");
                }
            }
        }, BackpressureStrategy.MISSING) // 使用BackpressureStrategy.MISSING背壓策略
                // 線程切換，異步操作
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Subscriber<String>() {
                    @Override
                    public void onSubscribe(Subscription s) {
                        LogUtil.d(TAG + "--onSubscribe");
                        s.request(Integer.MAX_VALUE);
                    }

                    @Override
                    public void onNext(String s) {
                        LogUtil.d(TAG + "--onNext  接收到:" + s);
                    }

                    @Override
                    public void onError(Throwable t) {
                        LogUtil.d(TAG + "--onError  error=" + t);
                    }

                    @Override
                    public void onComplete() {
                        LogUtil.d(TAG + "--onComplete");
                    }
                });

我們使用BackpressureStrategy.MISSING背壓策略，觀察者接收request(Integer.MAX_VALUE)，此值也爲推薦值。

結果：

我們看到，當發送了128個事件後，再發送第129個事件時候，拋了MissingBackpressureException異常，而且我們設置了觀察者接收也未接收到數據，說明是先存入緩存區隊列，再發送，當緩存區中拋異常後，就停止了onNext()事件，我們可以驗證一下，當設置被觀察者發送128事件。

        Flowable.create(new FlowableOnSubscribe<String>() {
            @Override
            public void subscribe(FlowableEmitter<String> emitter) throws Exception {
                // *******  發送128個事件  ********
                for (int x = 0; x < 128; x++) {
                    emitter.onNext(x + "事件");
                    LogUtil.d(TAG + "--subscribe  發送了" + x + "個事件");
                }
            }
        }, BackpressureStrategy.MISSING)
                // 線程切換，異步操作
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Subscriber<String>() {
                    @Override
                    public void onSubscribe(Subscription s) {
                        LogUtil.d(TAG + "--onSubscribe");
                        s.request(Integer.MAX_VALUE);
                    }

                    @Override
                    public void onNext(String s) {
                        LogUtil.d(TAG + "--onNext  接收到:" + s);
                    }

                    @Override
                    public void onError(Throwable t) {
                        LogUtil.d(TAG + "--onError  error=" + t);
                    }

                    @Override
                    public void onComplete() {
                        LogUtil.d(TAG + "--onComplete");
                    }
                });

就是在上面demo的基礎上，改了發送的事件個數，上游發送128個事件，剛好爲緩存區大小，並不拋異常。

結果：

我們看到程序沒有拋異常，並且正常打印了緩存區中的128個數據（從0開始），可以印證兩點

1、緩存區大小確實爲128

2、先存入緩存區後再獲取（如果異常，onNext直接不調用）

2.2.2、BackpressureStrategy.ERROR

當緩存區大小存滿（128）（默認緩存區大小128），被觀察者仍然繼續發送下一個事件時，直接拋出異常MissingBackpressureException

        Flowable.create(new FlowableOnSubscribe<String>() {
            @Override
            public void subscribe(FlowableEmitter<String> emitter) throws Exception {
                // 發送129個事件，模擬超出緩存區
                for (int x = 0; x < 129; x++) {
                    emitter.onNext(x + "事件");
                    LogUtil.d(TAG + "--subscribe  發送了" + x + "個事件");
                }
            }
        }, BackpressureStrategy.ERROR)
                // 線程切換，異步操作
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Subscriber<String>() {
                    @Override
                    public void onSubscribe(Subscription s) {
                        LogUtil.d(TAG + "--onSubscribe");
                        s.request(Integer.MAX_VALUE);
                    }

                    @Override
                    public void onNext(String s) {
                        LogUtil.d(TAG + "--onNext  接收到:" + s);
                    }

                    @Override
                    public void onError(Throwable t) {
                        LogUtil.d(TAG + "--onError  error=" + t);
                    }

                    @Override
                    public void onComplete() {
                        LogUtil.d(TAG + "--onComplete");
                    }
                });

使用 BackpressureStrategy.ERROR 背壓策略

結果：

[站外圖片上傳中...(image-b907e7-1577706002259)]

跟Missing一樣，直接拋了MissingBackpressureException異常且下游未接收到數據，同理，如果上游發送數據小於等於128，正常發送和接收。

2.2.3、BackpressureStrategy.BUFFER

當緩存區大小存滿（128），被觀察者仍然繼續發送下一個事件時，緩存區大小設置無限大, 即被觀察者可無限發送事件，但實際上是存放在緩存區。

       Flowable.create(new FlowableOnSubscribe<String>() {
            @Override
            public void subscribe(FlowableEmitter<String> emitter) throws Exception {
                // 發送129個事件，模擬超出緩存區
                for (int x = 0; x < 129; x++) {
                    emitter.onNext(x + "事件");
                    LogUtil.d(TAG + "--subscribe  發送了" + x + "個事件");
                }
            }
        }, BackpressureStrategy.BUFFER)
                // 線程切換，異步操作
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Subscriber<String>() {
                    @Override
                    public void onSubscribe(Subscription s) {
                        LogUtil.d(TAG + "--onSubscribe");
                        s.request(Integer.MAX_VALUE);
                    }

                    @Override
                    public void onNext(String s) {
                        LogUtil.d(TAG + "--onNext  接收到:" + s);
                    }

                    @Override
                    public void onError(Throwable t) {
                        LogUtil.d(TAG + "--onError  error=" + t);
                    }

                    @Override
                    public void onComplete() {
                        LogUtil.d(TAG + "--onComplete");
                    }
                });

使用 BackpressureStrategy.BUFFER 背壓策略

更改緩存區大小，不做限制。

結果：

可以看到，我們發送的129個事件全部發送且接收到了。

2.2.4、BackpressureStrategy.DROP

當緩存區大小存滿，被觀察者仍然繼續發送下一個事件時，超過緩存區大小（128）的事件會被全部丟棄

        Flowable.create(new FlowableOnSubscribe<String>() {
            @Override
            public void subscribe(FlowableEmitter<String> emitter) throws Exception {
                // 發送129個事件，模擬超出緩存區
                for (int x = 0; x < 129; x++) {
                    emitter.onNext(x + "事件");
                    LogUtil.d(TAG + "--subscribe  發送了" + x + "個事件");
                }
            }
        }, BackpressureStrategy.DROP)
                // 線程切換，異步操作
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Subscriber<String>() {
                    @Override
                    public void onSubscribe(Subscription s) {
                        LogUtil.d(TAG + "--onSubscribe");
                        s.request(Integer.MAX_VALUE);
                    }

                    @Override
                    public void onNext(String s) {
                        LogUtil.d(TAG + "--onNext  接收到:" + s);
                    }

                    @Override
                    public void onError(Throwable t) {
                        LogUtil.d(TAG + "--onError  error=" + t);
                    }

                    @Override
                    public void onComplete() {
                        LogUtil.d(TAG + "--onComplete");
                    }
                });

使用 BackpressureStrategy.DROP 背壓策略

丟掉大於緩存區的事件。

結果：

[站外圖片上傳中...(image-ea3cc7-1577706002259)]

結果很明瞭，並沒有拋異常同時也正常打印了，但是超過緩存區的那個事件被拋棄，並沒有獲取到。

2.2.5、BackpressureStrategy.LATEST

當緩存區大小存滿，被觀察者仍然繼續發送下一個事件時，只保存最新/最後發送的事件，其他超過緩存區大小（128）的事件會被全部丟棄

        Flowable.create(new FlowableOnSubscribe<String>() {
            @Override
            public void subscribe(FlowableEmitter<String> emitter) throws Exception {
                // 發送150個事件
                for (int x = 0; x < 150; x++) {
                    emitter.onNext(x + "事件");
                    LogUtil.d(TAG + "--subscribe  發送了" + x + "個事件");
                }
            }
        }, BackpressureStrategy.LATEST)
                // 線程切換，異步操作
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Subscriber<String>() {
                    @Override
                    public void onSubscribe(Subscription s) {
                        LogUtil.d(TAG + "--onSubscribe");
                        s.request(Integer.MAX_VALUE);
                    }

                    @Override
                    public void onNext(String s) {
                        LogUtil.d(TAG + "--onNext  接收到:" + s);
                    }

                    @Override
                    public void onError(Throwable t) {
                        LogUtil.d(TAG + "--onError  error=" + t);
                    }

                    @Override
                    public void onComplete() {
                        LogUtil.d(TAG + "--onComplete");
                    }
                });

使用 BackpressureStrategy.LATEST 背壓策略

發送了150個事件

當超出128時，會保存最新的一個事件，即會接收129個事件。

結果：

我們可以看到，觀察者端接收到129個數據，分別爲緩存區內數據，加上最新/最後一條數據，中間數據均被丟棄。

2.3、同步情況下`Flowable`

前面說過，背壓前提是異步操作下，在同步下，我們並不會有背壓一說，因爲在同一個線程，發送數據後總是要等下游處理了纔會發送第二條數據，不會存在緩衝區，如下：

       Flowable.create(new FlowableOnSubscribe<String>() {
            @Override
            public void subscribe(FlowableEmitter<String> emitter) throws Exception {
                LogUtil.d(TAG + "--subscribe  發送事件一");
                emitter.onNext("事件一");
                LogUtil.d(TAG + "--subscribe  發送事件二");
                emitter.onNext("事件二");
                LogUtil.d(TAG + "--subscribe  發送事件三");
                emitter.onNext("事件三");
                LogUtil.d(TAG + "--subscribe  發送完成");
                emitter.onComplete();
            }
        }, BackpressureStrategy.ERROR).subscribe(new Subscriber<String>() {
            @Override
            public void onSubscribe(Subscription s) {
                LogUtil.d(TAG + "--onSubscribe");
                s.request(3);
            }

            @Override
            public void onNext(String s) {
                LogUtil.d(TAG + "--onNext  接收到:" + s);
            }

            @Override
            public void onError(Throwable t) {
                LogUtil.d(TAG + "--onError  error=" + t);
            }

            @Override
            public void onComplete() {
                LogUtil.d(TAG + "--onComplete");
            }
        });

結果：

可以看到，事件都是順序執行，發送一條接收一條，然後再執行下一條。

但是，我們可能會遇到這個一個情況，當上遊發送了四條數據，但是下游只接收三條？我們改一下demo如下：

       Flowable.create(new FlowableOnSubscribe<String>() {
            @Override
            public void subscribe(FlowableEmitter<String> emitter) throws Exception {
                LogUtil.d(TAG + "--subscribe  發送事件一");
                emitter.onNext("事件一");
                LogUtil.d(TAG + "--subscribe  發送事件二");
                emitter.onNext("事件二");
                LogUtil.d(TAG + "--subscribe  發送事件三");
                emitter.onNext("事件三");
                LogUtil.d(TAG + "--subscribe  發送事件四");
                emitter.onNext("事件四");
                LogUtil.d(TAG + "--subscribe  發送完成");
                emitter.onComplete();
            }
        }, BackpressureStrategy.ERROR).subscribe(new Subscriber<String>() {
            @Override
            public void onSubscribe(Subscription s) {
                LogUtil.d(TAG + "--onSubscribe");
                s.request(3);

            }

            @Override
            public void onNext(String s) {
                LogUtil.d(TAG + "--onNext  接收到:" + s);
            }

            @Override
            public void onError(Throwable t) {
                LogUtil.d(TAG + "--onError  error=" + t);
            }

            @Override
            public void onComplete() {
                LogUtil.d(TAG + "--onComplete");
            }
        });

可以看到，被觀察者發送了四個事件，但是觀察者只接收了三條。

結果：

[站外圖片上傳中...(image-2790ee-1577706002259)]

可以看到，同樣拋了MissingBackpressureException異常

這裏可以使用BUFFER的背壓策略來處理，但是我們爲了說明觀察者反向控制被觀察者，我們採用如下方案：

        Flowable.create(new FlowableOnSubscribe<String>() {
            @Override
            public void subscribe(FlowableEmitter<String> emitter) throws Exception {
                // 通過emitter.requested()獲取觀察者設置的接收的事件數目
                long requested = emitter.requested();
                LogUtil.d(TAG + "--subscribe 觀察者設置接收的事件數目:" + requested);

                for (int x = 0; x < requested; x++) {
                    LogUtil.d(TAG + "--subscribe  發送事件" + x);
                    emitter.onNext("發送事件" + x);
                }
                LogUtil.d(TAG + "--subscribe  發送完成");
                emitter.onComplete();
            }
        }, BackpressureStrategy.BUFFER).subscribe(new Subscriber<String>() {
            @Override
            public void onSubscribe(Subscription s) {
                LogUtil.d(TAG + "--onSubscribe");
                // 設置觀察者接收事件數目爲3
                s.request(3);

            }

            @Override
            public void onNext(String s) {
                LogUtil.d(TAG + "--onNext  接收到:" + s);
            }

            @Override
            public void onError(Throwable t) {
                LogUtil.e(TAG + "--onError  error=" + t);
            }

            @Override
            public void onComplete() {
                LogUtil.d(TAG + "--onComplete");
            }
        });

我們在subscribe中通過emitter.requested()獲取觀察者中設置的接收事件數目，來動態的發送數據，這樣就避免了上下游數據不同步問題。

結果：

2.4、使用操作符時背壓處理

我們前面都是通過create來創建Flowable，可以在Create第二個參數中傳入相應的背壓策略，Flowable所有的操作符都支持背壓，但是通過操作符創建的背壓策略默認爲BackpressureStrategy.ERROR，我們可以通過

onBackpressureBuffer()
onBackpressureDrop()
onBackpressureLatest()

三種方式來指定相應的背壓策略。

        Flowable.interval(1, TimeUnit.MILLISECONDS)
                .observeOn(Schedulers.io())
                .subscribe(new Subscriber<Long>() {
                    @Override
                    public void onSubscribe(Subscription s) {
                        Log.d(TAG, "onSubscribe");
                        subscription = s;
                        s.request(Long.MAX_VALUE); //默認可以接收Long.MAX_VALUE個事件
                    }

                    @Override
                    public void onNext(Long aLong) {
                        LogUtil.i(TAG + "--onNext  aLong=" + aLong);
                        try {
                            // 延時一秒接收
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }

                    @Override
                    public void onError(Throwable t) {
                        LogUtil.e(TAG + "--onError  error=" + t);
                    }

                    @Override
                    public void onComplete() {
                        LogUtil.i(TAG + "--onComplete");
                    }
                });

這裏我們通過 interval來創建Flowable，可以看到下游每一毫秒發送一條數據，下游一秒處理一條，上游明顯快於下游，處理不過來數據放入緩存池中，當緩存池中隊列滿時，就會拋異常，因爲其默認的背壓策略爲BackpressureStrategy.ERROR

結果：

我們可以通過onBackpressureXXX其指定相應的背壓策略。

結果：

[站外圖片上傳中...(image-b45029-1577706002259)]

當我們指定背壓策略爲BUFFER後，可以看到並沒有異常拋出，程序一直在打印輸出。

3、Single和SingleObserver

只發射單個數據或錯誤事件。

        Single.create(new SingleOnSubscribe<String>() {
            @Override
            public void subscribe(SingleEmitter<String> emitter) throws Exception {
                // 只能發送onSuccess或者onError，發射多條數據，只接受第一條
                emitter.onSuccess("Success");
                emitter.onError(new NullPointerException(""));
            }
        }).subscribe(new SingleObserver<String>() {
            @Override
            public void onSubscribe(Disposable d) {
                LogUtil.d(TAG + "--onSubscribe");
            }

            @Override
            public void onSuccess(String s) {
                LogUtil.d(TAG + "--onSuccess  s=" + s);
            }

            @Override
            public void onError(Throwable e) {
                LogUtil.e(TAG + "--onError  error=" + e.getMessage());
            }
        });

SingleEmitter發射器只能發送一條onSuccess或者onError數據，如果發射器發射多條數據，觀察者只能接收到第一條數據。

結果：

4、Completable和CompletableObserver

不發射數據，只處理 onComplete 和 onError 事件。

[圖片上傳失敗...(image-34cb09-1577706002259)]

方法onComplete與onError只可調用一個，同時調用，第一個生效。

5、Maybe和MaybeObserver

能夠發射0或者1個數據，要麼成功，要麼失敗。有點類似於Optional。

[站外圖片上傳中...(image-63ca30-1577706002259)]

onSuccess方法一次訂閱只能發送一次。

方法onComplete與onError只可調用一個，同時調用，第一個生效。

Rxjava2(二)、五種觀察者模式創建及背壓

1、Observable 和 Observer

2、Flowable 和 Subscriber

2.1、什麼是背壓

2.2、背壓策略

2.2.1、BackpressureStrategy.MISSING

2.2.2、BackpressureStrategy.ERROR

2.2.3、BackpressureStrategy.BUFFER

2.2.4、BackpressureStrategy.DROP

2.2.5、BackpressureStrategy.LATEST

2.3、同步情況下`Flowable`

2.4、使用操作符時背壓處理

3、Single和SingleObserver

4、Completable和CompletableObserver

5、Maybe和MaybeObserver

致遠OA及相關OA系統集成與二次開發

EXCEL公式使用總結

System.Object未被引用的程序集中定義

Java 信號量（semaphore）搭配CountDownLatch 實現多線程處理循環內邏輯並限制創建線程數

[轉帖]linux命令top內存顯示M兆或者G

【面試準備】項目經驗——接口自動化項目

Rxjava(三)、操作符的使用

自定義View(一)、基礎概念和知識點

Java註解基礎介紹及使用

多線程(二)、內置鎖 synchronized

Android註解及反射實戰--手寫ButterKnife

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

linux以太網驅動總結

Rxjava2(二)、五種觀察者模式創建及背壓

1、Observable 和 Observer

2、Flowable 和 Subscriber

2.1、什麼是背壓

2.2、背壓策略

2.2.1、BackpressureStrategy.MISSING

2.2.2、BackpressureStrategy.ERROR

2.2.3、BackpressureStrategy.BUFFER

2.2.4、BackpressureStrategy.DROP

2.2.5、BackpressureStrategy.LATEST

2.3、同步情況下Flowable

2.4、使用操作符時背壓處理

3、Single和SingleObserver

4、Completable和CompletableObserver

5、Maybe和MaybeObserver

2.3、同步情況下`Flowable`