RxJava2.0-Flowable类

简介
RxJava2.0提供了5中操作符的基类，分别为Observable，Flowable，Single，Completable，Maybe；前面几篇文章都是以Observable介绍相关的操作符，Observable是非背压，可选的多值基类，提供工厂方法，操作符和处理同步或者异步数据流的能力；Observable的操作符默认提供缓存空间大小128，但是大多数操作符实现类允许显示的设置缓存区大小。

Flowable类实现了Reactive-Streams模式，提供工厂方法，操作符和处理数据流的能力，支持背压，Flowable操作符默认的缓存空间大小128。

Flowable用法

Flowable.create(new FlowableOnSubscribe<Integer>() {
 
  @Override
  public void subscribe(@NonNull FlowableEmitter<Integer> emitter) throws Exception {
    for (int i = 0; i < 3; i++) {
      Log.e(tag, "发送:" + i);
      emitter.onNext(i);
    }
  }
}, BackpressureStrategy.ERROR).subscribe(new FlowableSubscriber<Integer>() {
 
  @Override
  public void onSubscribe(@NonNull Subscription s) {
    //如果不设置或者传入0，将会报错；一般情况下设置为Long.MAX_VALUE；
    s.request(Long.MAX_VALUE);
  }
 
  @Override
  public void onNext(Integer integer) {
    Log.e(tag, "接收" + integer);
  }
 
  @Override
  public void onError(Throwable t) {
    Log.e(tag, Log.getStackTraceString(t));
  }
 
  @Override
  public void onComplete() {
    Log.e(tag, "onComplete");
  }
});

运行结果

Flowable是Publisher接口的实现类，Publisher接口是无界的序列的元素提供者，根据订阅者的需求发布元素；能够在不同的时间点动态的为多个Subscriber订阅。

FlowableOnSubscribe接口有一个subscribe()方法，该方法接收允许以背压和可取消的方式发送事件FlowableEmitter实例；

FlowableEmitter接口也是继承Emitter接口，序列的发送事件，有一个requested()方法可以获取当前未完成的请求的数量，即还可以发送的事件个数；

create操作符多了一个背压策略参数；

1）MISSING：OnNext在没有任何缓冲或者删除的情况下发送，下流必须处理溢出；

2）ERROR：报MissingBackpressureException异常，

3）BUFFER：缓存空间扩展无限大，直到下游消耗onNext

4）DROP： 如果下游不能跟上，就放弃最近的onNext事件。

5）LATEST：如果下游不能跟上，就保留最近的onNext事件。

FlowableSubscriber接口是Subscriber的子类，必须在的实现在方法onSubscribe()调用Subscription的request()方法；否则后续的onNext()方法不执行；

Subscription接口代表了Subscriber对Publisher的一对一生命周期；内部有两个方法1）request(long n):在没有调用该方法之前，Publisher不会发送任何事件；该方法在累计需求量不超过Long.MAX_VALUE的前提下，随时都可以调用，一般情况下会设置为Long.MAX_VALUE；参数n为Publisher向被观察者请求元素的数量；Publisher发送的事件可以少于request()方法设置的数量；2）cancel():Publisher停止发送数据并且清空资源；

Flowable和Observable的区别

当上流的发送事件的速度远超过下流处理事件的能力的情况下，看下同步和异步两种情况的区别

同步:Observable和Flowable都是被观察者发送当前事件之后，一直阻塞到观察者处理完当前事件之后，才会发送下一个事件；

异步：Observable异步的情况下，被观察者不停的发送事件，直到所有事件发送完，不管观察者是否能够及时处理，就造成有大量的事假在在缓冲区等待处理，造成内存不断增加，甚至OOM;就需要采用Flowable的背压策略；

背压各种策略的运行结果
 

Flowable.create(new FlowableOnSubscribe<String>() {
 
  @Override
  public void subscribe(FlowableEmitter<String> emitter) throws Exception {
    for (int i = 0; i < 130; i++) {
      Log.e(tag, "发送 Flowable:" + i);
      emitter.onNext("Flowable:" + i);
    }
  }
}, BackpressureStrategy.MISSING).subscribeOn(Schedulers.newThread())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Subscriber<String>() {
 
  @Override
  public void onSubscribe(Subscription s) {
    s.request(Long.MAX_VALUE);
  }
 
  @Override
  public void onNext(String s) {
    try {
      Thread.sleep(100);
      Log.e(tag, s);
    } catch (InterruptedException e) {
      Log.e(tag, Log.getStackTraceString(e));
    }
  }
 
  @Override
  public void onError(Throwable t) {
    Log.e(tag, Log.getStackTraceString(t));
 }
 
  @Override
  public void onComplete() {
  }
});

 

1）MISSING：超过128，就直接报错io.reactivex.exceptions.MissingBackpressureException: Queue is full?!

2）ERROR：超过128，就直接报错 io.reactivex.exceptions.MissingBackpressureException: create: could not emit value due to lack of requests

3）BUFFER：缓存空间最大值，直到下游消耗onNext，被观察者不断的发送事件，等待观察者去处理和Observable情况一致；

4）DROP：如果下游不能跟上，就放弃最近的onNext事件，可以看下运行结果，之前接收前128个数据；

5）LATEST：如果下游不能跟上，就保留最近的onNext事件，中间的事件丢失，看下运行结果；

 

lowable的应用场景

Flowable是在Observable的基础上优化的，Flowable一般应用在异步情况下被观察者发送事件的速度超过观察者，并且观察者处理事件的能力比较慢的情况下；Flowable内部处理比较复杂耗时，一般情况下采用Observable就可以很好满足需求；

 

————————————————
版权声明：本文为CSDN博主「fengluoye2012」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/fengluoye2012/article/details/79297186