5章 RxJava背压策略

其他 2018-12-16 03:09:29 阅读次数: 0
版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/qq_30379689/article/details/84875258

CSDN学院课程地址

5. RxJava背压策略(BackpressureStrategy)

5.1 背压是什么

背压的概念是在平时业务开发时较为常见，大多数是针对高并发的业务，背压是必须考虑的因素之一。在异步场景中，由于数据流的发射速度高于数据流的接收速度，就会导致数据不能及时处理，从而导致数据流的阻塞。背压所要做的事情就是主动控制数据流发射的速度

在RxJava2.0中，推出了Flowable用来支持背压，去除了Observable对背压的支持，下面在背压策略的讲解中，我们都使用Flowable作为我们的响应类型。在使用背压时，只需要在create()方法中第二个参数添加背压策略即可

  1. 在订阅的时候如果使用FlowableSubscriber，那么需要通过s.request(Long.MAX_VALUE)去主动请求上游的数据项。如果遇到背压报错的时候，FlowableSubscriber默认已经将错误try-catch，并通过onError()进行回调，程序并不会崩溃
  2. 在订阅的时候如果使用Consumer，那么不需要主动去请求上游数据，默认已经调用了s.request(Long.MAX_VALUE)。如果遇到背压报错、且对Throwable的Consumer没有new出来，则程序直接崩溃
  3. 背压策略的上游的默认缓存池是128
public abstract class Flowable<T> implements Publisher<T> {
    /** The default buffer size. */
    static final int BUFFER_SIZE;
    static {
        BUFFER_SIZE = Math.max(1, Integer.getInteger("rx2.buffer-size", 128));
    }
}

5.2 MISSING

MISSING表示OnNext事件没有任何缓存和丢弃，下游要处理任何溢出，可以理解为相当于没有指定背压策略。Flowable相当于没有指定背压策略可以将下游要处理任何溢出理解为，上游发射的数据未得到处理，就会缓存起来，当缓存容量达到128时，再增加一个未处理的数据项，就会抛出MissingBackpressureException，且带有队列已经满了的友好提示。这里就好比一个大水缸，当水注满的时候，它就会把盖子盖上，不让你再继续注水了

这里我们模拟上游发送速度高于下游数据流的处理速度，在数据处理的时候加上Thread.sleep(1000)

public void missing() {
    Flowable.create(new FlowableOnSubscribe<Integer>() {
        @Override
        public void subscribe(FlowableEmitter<Integer> emitter) throws Exception {
            for (int i = 0; i < 129; i++) {
                emitter.onNext(i);
            }
        }
    }, BackpressureStrategy.MISSING)
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new FlowableSubscriber<Integer>() {
                @Override
                public void onSubscribe(Subscription s) {
                    s.request(Long.MAX_VALUE);
                }

                @Override
                public void onNext(Integer integer) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    Log.e("TAG", "onNext=" + integer);
                }

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

                @Override
                public void onComplete() {

                }
            });
}

输出

io.reactivex.exceptions.MissingBackpressureException: Queue is full?!

5.3 ERROR

ERROR表示在下游无法跟上时，会抛出MissingBackpressureException。可以将下游无法跟上理解为，上游发射的数据未得到处理，就会缓存起来，当缓存容量达到128时，再增加一个未处理的数据项，就会抛出MissingBackpressureException。这里好比一个大水缸，当水注满的时候，它会把水缸撑破了，直接破裂

public void error() {
    Flowable.create(new FlowableOnSubscribe<Integer>() {
        @Override
        public void subscribe(FlowableEmitter<Integer> emitter) throws Exception {
            for (int i = 0; i < 129; i++) {
                emitter.onNext(i);
            }
        }
    }, BackpressureStrategy.ERROR)
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new FlowableSubscriber<Integer>() {
                @Override
                public void onSubscribe(Subscription s) {
                    s.request(Long.MAX_VALUE);
                }

                @Override
                public void onNext(Integer integer) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    Log.e("TAG", "onNext=" + integer);
                }

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

                @Override
                public void onComplete() {

                }
            });
}

输出

io.reactivex.exceptions.MissingBackpressureException: create: could not emit value due to lack of requests

5.4 BUFFER

上游不断的发出onNext请求，直到下游处理完，上游发射的数据项的缓存池是无限大的，程序也不会抛出错误，但是要注意程序OOM的现象，因为缓存越大，占用的内存就越多。例子中发射129个数据项，然而程序并没有崩溃，只会一直读取缓存池的数据项，直到数据项被处理完。这里就是一个无限大的水缸

背压策略除了BUFFER策略的缓存池是无限大之外，其他默认的缓存池都是128

public void buffer() {
    Flowable.create(new FlowableOnSubscribe<Integer>() {
        @Override
        public void subscribe(FlowableEmitter<Integer> emitter) throws Exception {
            for (int i = 0; i < 1000; i++) {
                emitter.onNext(i);
            }
        }
    }, BackpressureStrategy.BUFFER)
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new FlowableSubscriber<Integer>() {
                @Override
                public void onSubscribe(Subscription s) {
                    s.request(Long.MAX_VALUE);
                }

                @Override
                public void onNext(Integer integer) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    Log.e("TAG", "onNext=" + integer);
                }

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

                @Override
                public void onComplete() {

                }
            });
}

输出

onNext=0
onNext=1
onNext=2
......
onNext=998
onNext=999

5.5 DROP

会在下游跟不上速度时，把onNext的值丢弃，简单的说就是，超过缓存区大小（128）的数据项都会被丢弃。例子中通过发射800个数据项，那么我们只会收到0-127的数据项。如果我们再次调用request()，这时候取到的数据就是上一次request()后的128个数据。这里好比一个大水缸，当水注满的时候，水还是在继续的流，一旦有request调用的时候，它就会去取出水缸里的所有水，这时候水缸就是空的，但水一直在流，所以水缸马上又会被注满，这个时候就要等request再次取出水缸里的水

public void drop() {
    Flowable.create(new FlowableOnSubscribe<Integer>() {
        @Override
        public void subscribe(FlowableEmitter<Integer> emitter) throws Exception {
            for (int i = 0; i < 1000; i++) {
                emitter.onNext(i);
            }
        }
    }, BackpressureStrategy.DROP)
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new FlowableSubscriber<Integer>() {
                @Override
                public void onSubscribe(Subscription s) {
                    s.request(Long.MAX_VALUE);
                }

                @Override
                public void onNext(Integer integer) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    Log.e("TAG", "onNext=" + integer);
                }

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

                @Override
                public void onComplete() {

                }
            });
}

输出

onNext=0
onNext=1
onNext=2
......
onNext=127

5.6 LATEST

LATEST与Drop策略一样，如果超过缓存池容量大小的数据项都会被丢弃。不同的是，不管缓存池的状态如何，LATEST都会将最后一条数据强行放入缓存池中。这里的水缸容纳下了最后一滴水

public void latest() {
    Flowable.create(new FlowableOnSubscribe<Integer>() {
        @Override
        public void subscribe(FlowableEmitter<Integer> emitter) throws Exception {
            for (int i = 0; i < 1000; i++) {
                emitter.onNext(i);
            }
        }
    }, BackpressureStrategy.LATEST)
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new FlowableSubscriber<Integer>() {
                @Override
                public void onSubscribe(Subscription s) {
                    s.request(Long.MAX_VALUE);
                }

                @Override
                public void onNext(Integer integer) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    Log.e("TAG", "onNext=" + integer);
                }

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

                @Override
                public void onComplete() {

                }
            });
}

输出

onNext=0
onNext=1
......
onNext=126
onNext=127
onNext=999

5.7 小结

  1. MISSING:没有任何缓存和丢弃，下游要处理任何溢出
  2. ERROR:下游的处理速度无法跟上上游的发射速度时报错
  3. BUFFER:数据项的缓存池无限大
  4. DROP:下游的处理速度无法跟上上游的发射速度时丢弃
  5. LATEST:最后一条数据项被强行放入缓存池

猜你喜欢

转载自blog.csdn.net/qq_30379689/article/details/84875258
今日推荐
基于大语言模型的开源知识库问答系统 MaxKB GitHub Star 数量突破 5,000 个！
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
报告：Django 仍然是 74% 开发者的首选
《2024 年一季度互联网投融资运行情况》研究报告
15 年前上了“FFmpeg 耻辱柱”，今天他还得谢谢咱——腾讯QQPlayer一雪前耻？
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
周排行
BPM为企业带来的实际利益
好程序员web前端分享css常用属性缩写
Java文件下载（excel）
css样式的动态添加及显示和隐藏等零碎用法
axios全局配置以及拦截器
使用Logstash来实时同步MySQL和log日志数据到ES
C++获取当前时间（年月日、时分秒、毫秒）
Odoo产品分析 (四) -- 工具板块(11) -- 网站即时聊天(1)
Java环境配置正确，但是java、javac、java -version均返回“不是内部或外部命令，也不是可运行的程序或批处理文件”？
01 官网下载各种CentOS教程（超详细版）
每日归档
更多
2024-05-14(0)
2024-05-13(18)
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022