RxJava2 背压

RxJava2 背压

水管

Backpressure

先看一个失败的案例：

//zip
        Observable observable1 = Observable.create(e -> {
            for (int i = 0; ; i++) {
                e.onNext(i);
            }
        }).subscribeOn(Schedulers.io());

        Observable observable2 = Observable.create(e -> {
            e.onNext("A");
        }).subscribeOn(Schedulers.io());

        Observable.zip(observable1, observable2, (Integer integer, String s) -> integer + s
        ).observeOn(AndroidSchedulers.mainThread())
                .subscribe(s -> showLog("" + s)
                        , throwable -> showLog("" + throwable)
                );

上游无限发，下游发一个，最终内存崩了

Backpressure就是一个队列容器，也就是“水缸”，上游不停的发事件，太快了下游根本消耗不过来，怎么办，那就放到一个水缸里，然后下游在水缸里取数据，但是如果上游水流太猛了，水缸也装满了，这时候就很无奈了，水缸溢出来，就OOM了。

上面说的这个是异步，但是同步的状态下，那就是上游发一个，下游就消耗一个，也就没水缸了，那就不一样。

Observable.create(e -> {
            for (int i = 0; ; i++) {
                e.onNext(i);
            }
        }).subscribe(s -> {
            Thread.sleep(2000);
            showLog("" + s);
        });

这样就平缓了。

有一个疑问：

Observable.create(e -> {
            for (int i = 0; ; i++) {
                e.onNext(i);
            }
        }).observeOn(AndroidSchedulers.mainThread())
                .subscribe(s -> {
            Thread.sleep(2000);
            showLog("" + s);
        });

还有

        Observable.create(e -> {
            for (int i = 0; ; i++) {
                e.onNext(i);
            }
        }).subscribeOn(AndroidSchedulers.mainThread())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(s -> {
                    Thread.sleep(2000);
                    showLog("" + s);
                });

下面两个和上面的区别是什么？下面的就容易OOM，而且还没有打印的日志

如何解决水缸溢出的问题呢，一个是将上流流入水缸的水速变缓，就是让一部分倒在地上
1、筛选：filter；
2、取样：sample；每隔一段时间取一个
这样就丢失不少事件

另一个就是减缓速度：

Observable.create(e -> {
            for (int i = 0; ; i++) {
                e.onNext(i);
                Thread.sleep(2000);
            }
        }).subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(s -> {
                    showLog("" + s);
                });

发一个事件歇两秒

Flowable

基本用法

Flowable<Integer> upStream = Flowable.create(e -> {
            showLog("emit 1");
            e.onNext(1);
            showLog("emit 2");
            e.onNext(2);
            showLog("emit 3");
            e.onNext(3);
            showLog("emit complete");
            e.onComplete();
        }, BackpressureStrategy.ERROR);

        Subscriber<Integer> downSream = new Subscriber<Integer>() {
            @Override
            public void onSubscribe(Subscription s) {
                showLog("onSubscribe");
                s.request(Long.MAX_VALUE);
            }

            @Override
            public void onNext(Integer integer) {
                showLog("onNext" + integer);
            }

            @Override
            public void onError(Throwable t) {
                showLog("" + t);
            }

            @Override
            public void onComplete() {
                showLog("onComplete");
            }
        };

        upStream.subscribe(downSream);

打印Log

01-16 04:46:48.489 3314-3314/com.xiey94.rxjava2 E/ccer: onSubscribe
01-16 04:46:48.489 3314-3314/com.xiey94.rxjava2 E/ccer: emit 1
01-16 04:46:48.489 3314-3314/com.xiey94.rxjava2 E/ccer: onNext1
01-16 04:46:48.489 3314-3314/com.xiey94.rxjava2 E/ccer: emit 2
01-16 04:46:48.489 3314-3314/com.xiey94.rxjava2 E/ccer: onNext2
01-16 04:46:48.489 3314-3314/com.xiey94.rxjava2 E/ccer: emit 3
01-16 04:46:48.489 3314-3314/com.xiey94.rxjava2 E/ccer: onNext3
01-16 04:46:48.489 3314-3314/com.xiey94.rxjava2 E/ccer: emit complete
01-16 04:46:48.489 3314-3314/com.xiey94.rxjava2 E/ccer: onComplete

我们注意到这次和Observable有些不同. 首先是创建Flowable的时候增加了一个参数, 这个参数是用来选择背压,也就是出现上下游流速不均衡的时候应该怎么处理的办法, 这里我们直接用BackpressureStrategy.ERROR这种方式, 这种方式会在出现上下游流速不均衡的时候直接抛出一个异常,这个异常就是著名的MissingBackpressureException.

BackpressureStrategy.ERROR：上下游流速不均衡的时候直接抛出一个异常；
BackpressureStrategy.BUFFER：有多少装多少；
BackpressureStrategy.DROP：装不下就扔掉；
BackpressureStrategy.LATEST：同上，但是会缓存一条最新的数据；

当使用操作符的时候，也可以选择策略：

onBackpressureBuffer()
onBackpressureDrop()
onBackpressureLatest()

另外的一个区别是在下游的onSubscribe方法中传给我们的不再是Disposable了, 而是Subscription, 它俩有什么区别呢, 首先它们都是上下游中间的一个开关, 之前我们说调用Disposable.dispose()方法可以切断水管, 同样的调用Subscription.cancel()也可以切断水管, 不同的地方在于Subscription增加了一个void request(long n)方法, 这个方法有什么用呢, 在上面的代码中也有这么一句代码:

s.request(Long.MAX_VALUE);

我们把request当做是一种能力, 当成下游处理事件的能力, 下游能处理几个就告诉上游我要几个, 这样只要上游根据下游的处理能力来决定发送多少事件, 就不会造成一窝蜂的发出一堆事件来, 从而导致OOM. 这也就完美的解决之前我们所学到的两种方式的缺陷, 过滤事件会导致事件丢失, 减速又可能导致性能损失. 而这种方式既解决了事件丢失的问题, 又解决了速度的问题, 完美 !

线程异步的时候，如果没加这句，那就是上游不停的发，下游还是接收不到，但是上游也不是没有限制，也有一个缓存水缸，大小就是128，超了就溢出了。

当上游的128发完了之后就不发了，然后等待下游消费，当消费了96个的时候，上游又开始发射事件，发射96个，这个数字是零界点。

水管的一个例子：
读取大文件（因为手机系统是android6.0的，要运行时请求权限，所以我就放到了assert中了）：

    protected void readTxt() {
        Flowable.create((FlowableEmitter<String> e) -> {
            InputStream is = getAssets().open("诛仙.txt");
            InputStreamReader inputStreamReader = new InputStreamReader(is);

            BufferedReader br = new BufferedReader(inputStreamReader);

            String str;
            while ((str = br.readLine()) != null && !e.isCancelled()) {
                while (e.requested() == 0) {
                    if (e.isCancelled()) {
                        break;
                    }
                }
                e.onNext(str);
            }
            br.close();
            inputStreamReader.close();
            e.onComplete();
        }, BackpressureStrategy.ERROR)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Subscriber<String>() {
                    @Override
                    public void onSubscribe(Subscription s) {
                        subscription = s;
                        s.request(1);
                    }

                    @Override
                    public void onNext(String s) {
                        showLog(s);
                        try {
                            Thread.sleep(2000);
                            subscription.request(1);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }

                    }

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

                    @Override
                    public void onComplete() {

                    }
                });

    }

    Subscription subscription;

打印Log：

---