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: