前言

最近学习了一下RxJava,发现是个好东西,有点相见恨晚的感觉,一开始学习了RxJava 1.x,看了很多国内的博客,有点理解了,后来发现现在都 2.x 了,于是各种搜索,最后发现Season_zlc写的系列教程通俗易懂,非常适合初学者。因此在这里记录一下学习过程,感谢原作者的无私分享,希望在实战中提升对 RxJava 的理解。

Gradle 配置

要在Android中使用RxJava2, 先添加Gradle配置,最新的版本可在GitHub找到。
RxJavaRxAndroid

  compile "io.reactivex.rxjava2:rxjava:2.0.7"
  compile "io.reactivex.rxjava2:rxandroid:2.0.1"

第一式 亢龙有悔

概述

网上也有很多介绍RxJava原理的文章,通常这些文章都从观察者模式开始,先讲观察者,被观察者,订阅关系巴拉巴拉一大堆,说实话,当我第一次看到这些文章的时候已经被这些名词给绕晕了,用了很长的时间才理清楚它们之间的关系。可能是我太蠢了,境界不够,领会不到那么多高大上的名词.

今天我用两根水管代替观察者和被观察者, 试图用通俗易懂的话把它们的关系解释清楚, 在这里我将从事件流这个角度来说明RxJava的基本工作原理。

正文

先假设有两根水管:

1.1
1.1

上面一根水管为事件产生的水管,叫它上游吧,下面一根水管为事件接收的水管叫它下游吧。

两根水管通过一定的方式连接起来,使得上游每产生一个事件,下游就能收到该事件。注意这里和官网的事件图是反过来的, 这里的事件发送的顺序是先1,后2,后3这样的顺序, 事件接收的顺序也是先1,后2,后3的顺序, 我觉得这样更符合我们普通人的思维, 简单明了.

这里的上游下游就分别对应着RxJava中的ObservableObserver,它们之间的连接就对应着 subscribe(),因此这个关系用RxJava来表示就是:

  //创建一个上游 Observable:
  Observable<Integer> observable = Observable.create(new ObservableOnSubscribe<Integer>() {
      @Override
      public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
          emitter.onNext(1);
          emitter.onNext(2);
          emitter.onNext(3);
          emitter.onComplete();
      }
  });
  //创建一个下游 Observer
  Observer<Integer> observer = new Observer<Integer>() {
      @Override
      public void onSubscribe(Disposable d) {
          Log.d(TAG, "subscribe");
      }

      @Override
      public void onNext(Integer value) {
          Log.d(TAG, "" + value);
      }

      @Override
      public void onError(Throwable e) {
          Log.d(TAG, "error");
      }

      @Override
      public void onComplete() {
          Log.d(TAG, "complete");
      }
  };
  //建立连接
  observable.subscribe(observer);

这个运行的结果就是:

  12-02 03:37:17.818 4166-4166/zlc.season.rxjava2demo D/TAG: subscribe
  12-02 03:37:17.819 4166-4166/zlc.season.rxjava2demo D/TAG: 1
  12-02 03:37:17.819 4166-4166/zlc.season.rxjava2demo D/TAG: 2
  12-02 03:37:17.819 4166-4166/zlc.season.rxjava2demo D/TAG: 3
  12-02 03:37:17.819 4166-4166/zlc.season.rxjava2demo D/TAG: complete

注意: 只有当上游和下游建立连接之后, 上游才会开始发送事件. 也就是调用了 subscribe() 方法之后才开始发送事件.

把这段代码连起来写就成了RxJava引以为傲的链式操作:

  Observable.create(new ObservableOnSubscribe<Integer>() {
      @Override
      public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
          emitter.onNext(1);
          emitter.onNext(2);
          emitter.onNext(3);
          emitter.onComplete();
      }
  }).subscribe(new Observer<Integer>() {
      @Override
      public void onSubscribe(Disposable d) {
          Log.d(TAG, "subscribe");
      }

      @Override
      public void onNext(Integer value) {
          Log.d(TAG, "" + value);
      }

      @Override
      public void onError(Throwable e) {
          Log.d(TAG, "error");
      }

      @Override
      public void onComplete() {
          Log.d(TAG, "complete");
      }
  });

接下来解释一下其中两个陌生的玩意: ObservableEmitterDisposable.

ObservableEmitterEmitter 是发射器的意思,那就很好猜了,这个就是用来发出事件的,它可以发出三种类型的事件,通过调用emitter的 onNext(T value)onComplete()onError(Throwable error)就可以分别发出next事件、complete事件和error事件。
但是,请注意,并不意味着你可以随意乱七八糟发射事件,需要满足一定的规则:

  • 上游可以发送无限个onNext, 下游也可以接收无限个onNext.
  • 当上游发送了一个onComplete后, 上游onComplete之后的事件将会继续发送, 而下游收到onComplete事件之后将不再继续接收事件.
  • 当上游发送了一个onError后, 上游onError之后的事件将继续发送, 而下游收到onError事件之后将不再继续接收事件.
  • 上游可以不发送onComplete或onError.
  • 最为关键的是onComplete和onError必须唯一并且互斥, 即不能发多个onComplete, 也不能发多个onError, 也不能先发一个onComplete, 然后再发一个onError, 反之亦然

    注: 关于onComplete和onError唯一并且互斥这一点, 是需要自行在代码中进行控制, 如果你的代码逻辑中违背了这个规则, 并不一定会导致程序崩溃. 比如发送多个onComplete是可以正常运行的, 依然是收到第一个onComplete就不再接收了, 但若是发送多个onError, 则收到第二个onError事件会导致程序会崩溃.

以上几个规则用示意图表示如下:
| Action | 示意图 |
| —————– | ———– |
| 只发送onNext事件 |

next
next
|
| 发送onComplete事件 |
complete
complete
|
| 发送onError事件 |
error
error
|

介绍了ObservableEmitter, 接下来介绍Disposable, 这个单词的字面意思是一次性用品,用完即可丢弃的. 那么在RxJava中怎么去理解它呢, 对应于上面的水管的例子, 我们可以把它理解成两根管道之间的一个机关, 当调用它的 dispose()方法时, 它就会将两根管道切断, 从而导致下游收不到事件.

注意: 调用dispose()并不会导致上游不再继续发送事件, 上游会继续发送剩余的事件.

来看个例子, 我们让上游依次发送1,2,3,complete,4,在下游收到第二个事件之后, 切断水管, 看看运行结果:

  Observable.create(new ObservableOnSubscribe<Integer>() {
      @Override
      public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
          Log.d(TAG, "emit 1");
          emitter.onNext(1);
          Log.d(TAG, "emit 2");
          emitter.onNext(2);
          Log.d(TAG, "emit 3");
          emitter.onNext(3);
          Log.d(TAG, "emit complete");
          emitter.onComplete();
          Log.d(TAG, "emit 4");
          emitter.onNext(4);
      }
  }).subscribe(new Observer<Integer>() {
      private Disposable mDisposable;
      private int i;

      @Override
      public void onSubscribe(Disposable d) {
          Log.d(TAG, "subscribe");
          mDisposable = d;
      }

      @Override
      public void onNext(Integer value) {
          Log.d(TAG, "onNext: " + value);
          i++;
          if (i == 2) {
              Log.d(TAG, "dispose");
              mDisposable.dispose();
              Log.d(TAG, "isDisposed : " + mDisposable.isDisposed());
          }
      }

      @Override
      public void onError(Throwable e) {
          Log.d(TAG, "error");
      }

      @Override
      public void onComplete() {
          Log.d(TAG, "complete");
      }
  });

运行结果为:

  12-02 06:54:07.728 7404-7404/zlc.season.rxjava2demo D/TAG: subscribe
  12-02 06:54:07.728 7404-7404/zlc.season.rxjava2demo D/TAG: emit 1
  12-02 06:54:07.728 7404-7404/zlc.season.rxjava2demo D/TAG: onNext: 1
  12-02 06:54:07.728 7404-7404/zlc.season.rxjava2demo D/TAG: emit 2
  12-02 06:54:07.728 7404-7404/zlc.season.rxjava2demo D/TAG: onNext: 2
  12-02 06:54:07.728 7404-7404/zlc.season.rxjava2demo D/TAG: dispose
  12-02 06:54:07.728 7404-7404/zlc.season.rxjava2demo D/TAG: isDisposed : true
  12-02 06:54:07.728 7404-7404/zlc.season.rxjava2demo D/TAG: emit 3
  12-02 06:54:07.728 7404-7404/zlc.season.rxjava2demo D/TAG: emit complete
  12-02 06:54:07.728 7404-7404/zlc.season.rxjava2demo D/TAG: emit 4

从运行结果我们看到, 在收到onNext 2这个事件后, 切断了水管, 但是上游仍然发送了3, complete, 4这几个事件, 而且上游并没有因为发送了onComplete而停止. 同时可以看到下游的 onSubscribe()方法是最先调用的.
Disposable的用处不止这些, 后面讲解到了线程的调度之后, 我们会发现它的重要性. 随着后续深入的讲解, 我们会在更多的地方发现它的身影.
另外, subscribe()有多个重载的方法:

  public final Disposable subscribe() {}
  public final Disposable subscribe(Consumer<? super T> onNext) {}
  public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError) {}
  public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete) {}
  public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete, Consumer<? super Disposable> onSubscribe) {}
  public final void subscribe(Observer<? super T> observer) {}

最后一个带有Observer参数的我们已经使用过了,这里对其他几个方法进行说明.

  • 不带任何参数的 subscribe()表示下游不关心任何事件,你上游尽管发你的数据去吧, 老子可不管你发什么.
  • 带有一个Consumer参数的方法表示下游只关心onNext事件, 其他的事件我假装没看见, 因此我们如果只需要onNext事件可以这么写:
    Observable.create(new ObservableOnSubscribe<Integer>() {
        @Override
        public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
            Log.d(TAG, "emit 1");
            emitter.onNext(1);
            Log.d(TAG, "emit 2");
            emitter.onNext(2);
            Log.d(TAG, "emit 3");
            emitter.onNext(3);
            Log.d(TAG, "emit complete");
            emitter.onComplete();
            Log.d(TAG, "emit 4");
            emitter.onNext(4);
        }
    }).subscribe(new Consumer<Integer>() {
        @Override
        public void accept(Integer integer) throws Exception {
            Log.d(TAG, "onNext: " + integer);
        }
    });
    
  • 其他几个方法同理, 这里就不一一解释了.

第二式 飞龙在天

概述

上一节教程讲解了最基本的RxJava2的使用, 在本节中, 我们将学习RxJava强大的线程控制.

正文

还是以之前的例子, 两根水管:

2.1
2.1

正常情况下, 上游和下游是工作在同一个线程中的, 也就是说上游在哪个线程发事件, 下游就在哪个线程接收事件.

在RxJava中, 当我们在主线程中去创建一个上游Observable来发送事件, 则这个上游默认就在主线程发送事件.

当我们在主线程去创建一个下游Observer来接收事件, 则这个下游默认就在主线程中接收事件, 来看段代码:

  @Override
  protected void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      setContentView(R.layout.activity_main);

      Observable<Integer> observable = Observable.create(new ObservableOnSubscribe<Integer>() {
          @Override
          public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
              Log.d(TAG, "Observable thread is : " + Thread.currentThread().getName());
              Log.d(TAG, "emit 1");
              emitter.onNext(1);
          }
      });

      Consumer<Integer> consumer = new Consumer<Integer>() {
          @Override
          public void accept(Integer integer) throws Exception {
              Log.d(TAG, "Observer thread is :" + Thread.currentThread().getName());
              Log.d(TAG, "onNext: " + integer);
          }
      };

      observable.subscribe(consumer);
  }

在主线程中分别创建上游和下游, 然后将他们连接在一起, 同时分别打印出它们所在的线程, 运行结果为:

  D/TAG: Observable thread is : main
  D/TAG: emit 1
  D/TAG: Observer thread is :main
  D/TAG: onNext: 1

这就验证了刚才所说, 上下游默认是在同一个线程工作.

这样肯定是满足不了我们的需求的, 我们更多想要的是这么一种情况, 在子线程中做耗时的操作, 然后回到主线程中来操作UI, 用图片来描述就是下面这个图片:

2.2
2.2

在这个图中, 我们用黄色水管表示子线程, 深蓝色水管表示主线程.

要达到这个目的, 我们需要先改变上游发送事件的线程, 让它去子线程中发送事件, 然后再改变下游的线程, 让它去主线程接收事件. 通过RxJava内置的线程调度器可以很轻松的做到这一点. 接下来看一段代码:

  @Override
  protected void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      setContentView(R.layout.activity_main);

      Observable<Integer> observable = Observable.create(new ObservableOnSubscribe<Integer>() {
          @Override
          public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
              Log.d(TAG, "Observable thread is : " + Thread.currentThread().getName());
              Log.d(TAG, "emit 1");
              emitter.onNext(1);
          }
      });

      Consumer<Integer> consumer = new Consumer<Integer>() {
          @Override
          public void accept(Integer integer) throws Exception {
              Log.d(TAG, "Observer thread is :" + Thread.currentThread().getName());
              Log.d(TAG, "onNext: " + integer);
          }
      };

      observable.subscribeOn(Schedulers.newThread())
              .observeOn(AndroidSchedulers.mainThread())
              .subscribe(consumer);
  }

还是刚才的例子, 只不过我们太添加了一点东西, 先来看看运行结果:

  D/TAG: Observable thread is : RxNewThreadScheduler-2
  D/TAG: emit 1
  D/TAG: Observer thread is :main
  D/TAG: onNext: 1

可以看到, 上游发送事件的线程的确改变了, 是在一个叫 RxNewThreadScheduler-2的线程中发送的事件, 而下游仍然在主线程中接收事件, 这说明我们的目的达成了, 接下来看看是如何做到的.
和上一段代码相比,这段代码只不过是增加了两行代码:

  .subscribeOn(Schedulers.newThread())
  .observeOn(AndroidSchedulers.mainThread())

简单的来说, subscribeOn() 指定的是上游发送事件的线程, observeOn() 指定的是下游接收事件的线程.

多次指定上游的线程只有第一次指定的有效, 也就是说多次调用subscribeOn() 只有第一次的有效, 其余的会被忽略.

多次指定下游的线程是可以的, 也就是说每调用一次observeOn() , 下游的线程就会切换一次.

在RxJava中, 已经内置了很多线程选项供我们选择, 例如有

  • Schedulers.io() 代表io操作的线程, 通常用于网络,读写文件等io密集型的操作
  • Schedulers.computation() 代表CPU计算密集型的操作, 例如需要大量计算的操作
  • Schedulers.newThread() 代表一个常规的新线程
  • AndroidSchedulers.mainThread() 代表Android的主线程

这些内置的Scheduler已经足够满足我们开发的需求, 因此我们应该使用内置的这些选项, 在RxJava内部使用的是线程池来维护这些线程, 所有效率也比较高.

实践

对于我们Android开发人员来说, 经常会将一些耗时的操作放在后台, 比如网络请求或者读写文件,操作数据库等等,等到操作完成之后回到主线程去更新UI, 有了上面的这些基础, 那么现在我们就可以轻松的去做到这样一些操作.

下面来举几个常用的场景.

网络请求

Android中有名的网络请求库就那么几个, Retrofit能够从中脱颖而出很大原因就是因为它支持RxJava的方式来调用, 下面简单讲解一下它的基本用法.

要使用 Retrofit,先添加Gradle配置,最新的版本可在GitHub找到。
RetrofitGson converterRxJava2 Adapterokhttplogging-interceptor

  //retrofit
  compile 'com.squareup.retrofit2:retrofit:2.2.0'
  //Gson converter
  compile 'com.squareup.retrofit2:converter-gson:2.2.0'
  //RxJava2 Adapter
  compile 'com.squareup.retrofit2:adapter-rxjava2:2.2.0'
  //okhttp
  compile 'com.squareup.okhttp3:okhttp:3.6.0'
  compile 'com.squareup.okhttp3:logging-interceptor:3.6.0'

随后定义Api接口:

  public interface Api {
      @GET
      Observable<LoginResponse> login(@Body LoginRequest request);

      @GET
      Observable<RegisterResponse> register(@Body RegisterRequest request);
  }

接着创建一个Retrofit客户端:

  private static Retrofit create() {
              OkHttpClient.Builder builder = new OkHttpClient().newBuilder();
              builder.readTimeout(10, TimeUnit.SECONDS);
              builder.connectTimeout(9, TimeUnit.SECONDS);

              if (BuildConfig.DEBUG) {
                  HttpLoggingInterceptor interceptor = new HttpLoggingInterceptor();
                  interceptor.setLevel(HttpLoggingInterceptor.Level.BODY);
                  builder.addInterceptor(interceptor);
              }

              return new Retrofit.Builder().baseUrl(ENDPOINT)
                      .client(builder.build())
                      .addConverterFactory(GsonConverterFactory.create())
                      .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
                      .build();
  }

发起请求就很简单了:

  Api api = retrofit.create(Api.class);
  api.login(request)
        .subscribeOn(Schedulers.io())               //在IO线程进行网络请求
       .observeOn(AndroidSchedulers.mainThread())  //回到主线程去处理请求结果
      .subscribe(new Observer<LoginResponse>() {
              @Override
          public void onSubscribe(Disposable d) {}

          @Override
          public void onNext(LoginResponse value) {}

          @Override
          public void onError(Throwable e) {
              Toast.makeText(mContext, "登录失败", Toast.LENGTH_SHORT).show();
          }

          @Override
          public void onComplete() {
              Toast.makeText(mContext, "登录成功", Toast.LENGTH_SHORT).show();
          }
      });

看似很完美, 但我们忽略了一点, 如果在请求的过程中Activity已经退出了, 这个时候如果回到主线程去更新UI, 那么APP肯定就崩溃了, 怎么办呢, 上一节我们说到了 Disposable , 说它是个开关, 调用它的 dispose()方法时就会切断水管, 使得下游收不到事件, 既然收不到事件, 那么也就不会再去更新UI了. 因此我们可以在Activity中将这个Disposable 保存起来, 当Activity退出时, 切断它即可.

那如果有多个Disposable 该怎么办呢, RxJava中已经内置了一个容器 CompositeDisposable, 每当我们得到一个Disposable时就调用 CompositeDisposable.add()将它添加到容器中, 在退出的时候, 调用 CompositeDisposable.clear() 即可切断所有的水管.

读写数据库

上面说了网络请求的例子, 接下来再看看读写数据库, 读写数据库也算一个耗时的操作, 因此我们也最好放在IO线程里去进行, 这个例子就比较简单, 直接上代码:

  public Observable<List<Record>> readAllRecords() {
              return Observable.create(new ObservableOnSubscribe<List<Record>>() {
                  @Override
                  public void subscribe(ObservableEmitter<List<Record>> emitter) throws Exception {
                      Cursor cursor = null;
                      try {
                          cursor = getReadableDatabase().rawQuery("select * from " + TABLE_NAME, new String[]{});
                          List<Record> result = new ArrayList<>();
                          while (cursor.moveToNext()) {
                              result.add(Db.Record.read(cursor));
                          }
                          emitter.onNext(result);
                          emitter.onComplete();
                      } finally {
                          if (cursor != null) {
                              cursor.close();
                          }
                      }
                  }
              }).subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread());
          }

好了节就到这里吧, 后面将会教大家如何使用RxJava中强大的操作符. 通过使用这些操作符可以很轻松的做到各种吊炸天的效果.

第三式 见龙在田

概述

上一节讲解了线程调度, 并且举了两个实际中的例子, 其中有一个登录的例子, 不知大家有没有想过这么一个问题, 如果是一个新用户, 必须先注册, 等注册成功之后再自动登录该怎么做呢.
很明显, 这是一个嵌套的网络请求, 首先需要去请求注册, 待注册成功回调了再去请求登录的接口.
我们当然可以想当然的写成这样:

  private void login() {
          api.login(new LoginRequest())
                  .subscribeOn(Schedulers.io())               //在IO线程进行网络请求
                  .observeOn(AndroidSchedulers.mainThread())  //回到主线程去处理请求结果
                  .subscribe(new Consumer<LoginResponse>() {
                      @Override
                      public void accept(LoginResponse loginResponse) throws Exception {
                          Toast.makeText(MainActivity.this, "登录成功", Toast.LENGTH_SHORT).show();
                      }
                  }, new Consumer<Throwable>() {
                      @Override
                      public void accept(Throwable throwable) throws Exception {
                          Toast.makeText(MainActivity.this, "登录失败", Toast.LENGTH_SHORT).show();
                      }
                  });
      }

      private void register() {
          api.register(new RegisterRequest())
                  .subscribeOn(Schedulers.io())               //在IO线程进行网络请求
                  .observeOn(AndroidSchedulers.mainThread())  //回到主线程去处理请求结果
                  .subscribe(new Consumer<RegisterResponse>() {
                      @Override
                      public void accept(RegisterResponse registerResponse) throws Exception {
                          Toast.makeText(MainActivity.this, "注册成功", Toast.LENGTH_SHORT).show();
                          login();   //注册成功, 调用登录的方法
                      }
                  }, new Consumer<Throwable>() {
                      @Override
                      public void accept(Throwable throwable) throws Exception {
                          Toast.makeText(MainActivity.this, "注册失败", Toast.LENGTH_SHORT).show();
                      }
                  });
      }

这样的代码能够工作, 但不够优雅, 通过本节的学习, 可以让我们用一种更优雅的方式来解决这个问题.

正文

先来看看最简单的变换操作符map吧.

Map

map是RxJava中最简单的一个变换操作符了, 它的作用就是对上游发送的每一个事件应用一个函数, 使得每一个事件都按照指定的函数去变化. 用事件图表示如下:

map
map

图中map中的函数作用是将圆形事件转换为矩形事件, 从而导致下游接收到的事件就变为了矩形.用代码来表示这个例子就是:

  Observable.create(new ObservableOnSubscribe<Integer>() {
              @Override
              public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                  emitter.onNext(1);
                  emitter.onNext(2);
                  emitter.onNext(3);
              }
          }).map(new Function<Integer, String>() {
              @Override
              public String apply(Integer integer) throws Exception {
                  return "This is result " + integer;
              }
          }).subscribe(new Consumer<String>() {
              @Override
              public void accept(String s) throws Exception {
                  Log.d(TAG, s);
              }
          });

在上游我们发送的是数字类型, 而在下游我们接收的是String类型, 中间起转换作用的就是map操作符, 运行结果为:

  D/TAG: This is result 1
  D/TAG: This is result 2
  D/TAG: This is result 3

通过Map, 可以将上游发来的事件转换为任意的类型, 可以是一个Object, 也可以是一个集合, 如此强大的操作符你难道不想试试?
接下来我们来看另外一个广为人知的操作符flatMap.

FlatMap

flatMap是一个非常强大的操作符, 先用一个比较难懂的概念说明一下:
FlatMap将一个发送事件的上游Observable变换为多个发送事件的Observables,然后将它们发射的事件合并后放进一个单独的Observable里.
这句话比较难以理解, 我们先通俗易懂的图片来详细的讲解一下, 首先先来看看整体的一个图片:

flatMap
flatMap

先看看上游, 上游发送了三个事件, 分别是1,2,3, 注意它们的颜色.
中间flatMap的作用是将圆形的事件转换为一个发送矩形事件和一个三角形事件的新的上游Observable.

上游每发送一个事件, flatMap都将创建一个新的水管, 然后发送转换之后的新的事件, 下游接收到的就是这些新的水管发送的数据. 这里需要注意的是, flatMap并不保证事件的顺序, 也就是图中所看到的, 并不是事件1就在事件2的前面. 如果需要保证顺序则需要使用concatMap.
说了原理, 我们还是来看看实际中的代码如何写吧:

  Observable.create(new ObservableOnSubscribe<Integer>() {
              @Override
              public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                  emitter.onNext(1);
                  emitter.onNext(2);
                  emitter.onNext(3);
              }
          }).flatMap(new Function<Integer, ObservableSource<String>>() {
              @Override
              public ObservableSource<String> apply(Integer integer) throws Exception {
                  final List<String> list = new ArrayList<>();
                  for (int i = 0; i < 3; i++) {
                      list.add("I am value " + integer);
                  }
                  return Observable.fromIterable(list).delay(10, TimeUnit.MILLISECONDS);
              }
          }).subscribe(new Consumer<String>() {
              @Override
              public void accept(String s) throws Exception {
                  Log.d(TAG, s);
              }
          });

如代码所示, 我们在flatMap中将上游发来的每个事件转换为一个新的发送三个String事件的水管, 为了看到flatMap结果是无序的,所以加了10毫秒的延时, 来看看运行结果吧:

  D/TAG: I am value 1
  D/TAG: I am value 1
  D/TAG: I am value 1
  D/TAG: I am value 3
  D/TAG: I am value 3
  D/TAG: I am value 3
  D/TAG: I am value 2
  D/TAG: I am value 2
  D/TAG: I am value 2

concatMap

这里也简单说一下concatMap吧, 它和flatMap的作用几乎一模一样, 只是它的结果是严格按照上游发送的顺序来发送的, 来看个代码吧:

  Observable.create(new ObservableOnSubscribe<Integer>() {
              @Override
              public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                  emitter.onNext(1);
                  emitter.onNext(2);
                  emitter.onNext(3);
              }
          }).concatMap(new Function<Integer, ObservableSource<String>>() {
              @Override
              public ObservableSource<String> apply(Integer integer) throws Exception {
                  final List<String> list = new ArrayList<>();
                  for (int i = 0; i < 3; i++) {
                      list.add("I am value " + integer);
                  }
                  return Observable.fromIterable(list).delay(10,TimeUnit.MILLISECONDS);
              }
          }).subscribe(new Consumer<String>() {
              @Override
              public void accept(String s) throws Exception {
                  Log.d(TAG, s);
              }
          });

只是将之前的flatMap改为了concatMap, 其余原封不动, 运行结果如下:

  D/TAG: I am value 1
  D/TAG: I am value 1
  D/TAG: I am value 1
  D/TAG: I am value 2
  D/TAG: I am value 2
  D/TAG: I am value 2
  D/TAG: I am value 3
  D/TAG: I am value 3
  D/TAG: I am value 3

可以看到, 结果仍然是有序的.

好了关于RxJava的操作符最基本的使用就讲解到这里了, RxJava中内置了许许多多的操作符, 这里通过讲解map和flatMap只是起到一个抛砖引玉的作用, 关于其他的操作符只要大家按照本文的思路去理解, 再仔细阅读文档, 应该是没有问题的了.

实践

如何优雅的解决嵌套请求, 只需要用flatMap转换一下就行了.
先回顾一下上一节的请求接口:

  public interface Api {
      @GET
      Observable<LoginResponse> login(@Body LoginRequest request);

      @GET
      Observable<RegisterResponse> register(@Body RegisterRequest request);
  }

可以看到登录和注册返回的都是一个上游Observable, 而我们的flatMap操作符的作用就是把一个Observable转换为另一个Observable, 因此结果就很显而易见了:

  api.register(new RegisterRequest())            //发起注册请求
                  .subscribeOn(Schedulers.io())               //在IO线程进行网络请求
                  .observeOn(AndroidSchedulers.mainThread())  //回到主线程去处理请求注册结果
                  .doOnNext(new Consumer<RegisterResponse>() {
                      @Override
                      public void accept(RegisterResponse registerResponse) throws Exception {
                          //先根据注册的响应结果去做一些操作
                      }
                  })
                  .observeOn(Schedulers.io())                 //回到IO线程去发起登录请求
                  .flatMap(new Function<RegisterResponse, ObservableSource<LoginResponse>>() {
                      @Override
                      public ObservableSource<LoginResponse> apply(RegisterResponse registerResponse) throws Exception {
                          return api.login(new LoginRequest());
                      }
                  })
                  .observeOn(AndroidSchedulers.mainThread())  //回到主线程去处理请求登录的结果
                  .subscribe(new Consumer<LoginResponse>() {
                      @Override
                      public void accept(LoginResponse loginResponse) throws Exception {
                          Toast.makeText(MainActivity.this, "登录成功", Toast.LENGTH_SHORT).show();
                      }
                  }, new Consumer<Throwable>() {
                      @Override
                      public void accept(Throwable throwable) throws Exception {
                          Toast.makeText(MainActivity.this, "登录失败", Toast.LENGTH_SHORT).show();
                      }
                  });

从这个例子也可以看到我们切换线程是多么简单.
下一节我们将会学到 zip 操作符.

第四式 鸿渐于陆

概述

下面学习zip这个操作符, 这个操作符也是比较牛逼的东西了, 涉及到的东西也比较多, 主要是一些细节上的东西太多, 通过学习这个操作符,可以为我们下一节的Backpressure做个铺垫.

正文

Zip通过一个函数将多个Observable发送的事件结合到一起,然后发送这些组合到一起的事件. 它按照严格的顺序应用这个函数。它只发射与发射数据项最少的那个Observable一样多的数据。
我们再用通俗易懂的图片来解释一下:

zip
zip

从这个图中可以看见, 这次上游和以往不同的是, 我们有两根水管了.
其中一根水管负责发送圆形事件 , 另外一根水管负责发送三角形事件 , 通过Zip操作符, 使得圆形事件和三角形事件 合并为了一个矩形事件.

  • 组合的过程是分别从 两根水管里各取出一个事件 来进行组合, 并且一个事件只能被使用一次, 组合的顺序是严格按照事件发送的顺利 来进行的, 也就是说不会出现圆形1 事件和三角形B 事件进行合并, 也不可能出现圆形2 和三角形A 进行合并的情况.
  • 最终下游收到的事件数量 是和上游中发送事件最少的那一根水管的事件数量 相同. 这个也很好理解, 因为是从每一根水管 里取一个事件来进行合并, 最少的 那个肯定就最先取完 , 这个时候其他的水管尽管还有事件 , 但是已经没有足够的事件来组合了, 因此下游就不会收到剩余的事件了.

分析了大概的原理, 我们还是劳逸结合, 先来看看实际中的代码怎么写吧:

  Observable<Integer> observable1 = Observable.create(new ObservableOnSubscribe<Integer>() {
      @Override
      public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
          Log.d(TAG, "emit 1");
          emitter.onNext(1);
          Log.d(TAG, "emit 2");
          emitter.onNext(2);
          Log.d(TAG, "emit 3");
          emitter.onNext(3);
          Log.d(TAG, "emit 4");
          emitter.onNext(4);
          Log.d(TAG, "emit complete1");
          emitter.onComplete();
      }
  });

  Observable<String> observable2 = Observable.create(new ObservableOnSubscribe<String>() {
      @Override
      public void subscribe(ObservableEmitter<String> emitter) throws Exception {
          Log.d(TAG, "emit A");
          emitter.onNext("A");
          Log.d(TAG, "emit B");
          emitter.onNext("B");
          Log.d(TAG, "emit C");
          emitter.onNext("C");
          Log.d(TAG, "emit complete2");
          emitter.onComplete();
      }
  });

  Observable.zip(observable1, observable2, new BiFunction<Integer, String, String>() {
      @Override
      public String apply(Integer integer, String s) throws Exception {
          return integer + s;
      }
  }).subscribe(new Observer<String>() {
      @Override
      public void onSubscribe(Disposable d) {
          Log.d(TAG, "onSubscribe");
      }

      @Override
      public void onNext(String value) {
          Log.d(TAG, "onNext: " + value);
      }

      @Override
      public void onError(Throwable e) {
          Log.d(TAG, "onError");
      }

      @Override
      public void onComplete() {
          Log.d(TAG, "onComplete");
      }
  });

我们分别创建了两个上游水管, 一个发送1,2,3,4,Complete, 另一个发送A,B,C,Complete, 接着用Zip把发出的事件组合, 来看看运行结果吧:

  D/TAG: onSubscribe
  D/TAG: emit 1
  D/TAG: emit 2
  D/TAG: emit 3
  D/TAG: emit 4
  D/TAG: emit complete1
  D/TAG: emit A
  D/TAG: onNext: 1A
  D/TAG: emit B
  D/TAG: onNext: 2B
  D/TAG: emit C
  D/TAG: onNext: 3C
  D/TAG: emit complete2
  D/TAG: onComplete

结果似乎是对的… 但是总感觉什么地方不对劲…
哪儿不对劲呢, 为什么感觉是水管一发送完了之后, 水管二才开始发送啊? 到底是不是呢, 我们来验证一下:

  Observable<Integer> observable1 = Observable.create(new ObservableOnSubscribe<Integer>() {
      @Override
      public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
          Log.d(TAG, "emit 1");
          emitter.onNext(1);
          Thread.sleep(1000);

          Log.d(TAG, "emit 2");
          emitter.onNext(2);
          Thread.sleep(1000);

          Log.d(TAG, "emit 3");
          emitter.onNext(3);
          Thread.sleep(1000);

          Log.d(TAG, "emit 4");
          emitter.onNext(4);
          Thread.sleep(1000);

          Log.d(TAG, "emit complete1");
          emitter.onComplete();
      }
  });

  Observable<String> observable2 = Observable.create(new ObservableOnSubscribe<String>() {
      @Override
      public void subscribe(ObservableEmitter<String> emitter) throws Exception {
          Log.d(TAG, "emit A");
          emitter.onNext("A");
          Thread.sleep(1000);

          Log.d(TAG, "emit B");
          emitter.onNext("B");
          Thread.sleep(1000);

          Log.d(TAG, "emit C");
          emitter.onNext("C");
          Thread.sleep(1000);

          Log.d(TAG, "emit complete2");
          emitter.onComplete();
      }
  });

  Observable.zip(observable1, observable2, new BiFunction<Integer, String, String>() {
      @Override
      public String apply(Integer integer, String s) throws Exception {
          return integer + s;
      }
  }).subscribe(new Observer<String>() {
      @Override
      public void onSubscribe(Disposable d) {
          Log.d(TAG, "onSubscribe");
      }

      @Override
      public void onNext(String value) {
          Log.d(TAG, "onNext: " + value);
      }

      @Override
      public void onError(Throwable e) {
          Log.d(TAG, "onError");
      }

      @Override
      public void onComplete() {
          Log.d(TAG, "onComplete");
      }
  });

这次我们在每发送一个事件之后加入了一秒钟的延时, 来看看运行结果吧, 注意这是个GIF图:

zip
zip

好像真的是先发送的水管一再发送的水管二呢, 为什么会有这种情况呢? 因为我们两根水管都是运行在同一个线程里, 同一个线程里执行代码肯定有先后顺序呀.

因此我们来稍微改一下, 不让他们在同一个线程, 不知道怎么切换线程的, 请掉头看前面几节.

  Observable<Integer> observable1 = Observable.create(new ObservableOnSubscribe<Integer>() {
      @Override
      public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
          Log.d(TAG, "emit 1");
          emitter.onNext(1);
          Thread.sleep(1000);

          Log.d(TAG, "emit 2");
          emitter.onNext(2);
          Thread.sleep(1000);

          Log.d(TAG, "emit 3");
          emitter.onNext(3);
          Thread.sleep(1000);

          Log.d(TAG, "emit 4");
          emitter.onNext(4);
          Thread.sleep(1000);

          Log.d(TAG, "emit complete1");
          emitter.onComplete();
      }
  }).subscribeOn(Schedulers.io());

  Observable<String> observable2 = Observable.create(new ObservableOnSubscribe<String>() {
      @Override
      public void subscribe(ObservableEmitter<String> emitter) throws Exception {
          Log.d(TAG, "emit A");
          emitter.onNext("A");
          Thread.sleep(1000);

          Log.d(TAG, "emit B");
          emitter.onNext("B");
          Thread.sleep(1000);

          Log.d(TAG, "emit C");
          emitter.onNext("C");
          Thread.sleep(1000);

          Log.d(TAG, "emit complete2");
          emitter.onComplete();
      }
  }).subscribeOn(Schedulers.io());

  Observable.zip(observable1, observable2, new BiFunction<Integer, String, String>() {
      @Override
      public String apply(Integer integer, String s) throws Exception {
          return integer + s;
      }
  }).subscribe(new Observer<String>() {
      @Override
      public void onSubscribe(Disposable d) {
          Log.d(TAG, "onSubscribe");
      }

      @Override
      public void onNext(String value) {
          Log.d(TAG, "onNext: " + value);
      }

      @Override
      public void onError(Throwable e) {
          Log.d(TAG, "onError");
      }

      @Override
      public void onComplete() {
          Log.d(TAG, "onComplete");
      }
  });

好了, 这次我们让水管都在IO线程里发送事件, 再来看看运行结果:

  D/TAG: onSubscribe
  D/TAG: emit A
  D/TAG: emit 1
  D/TAG: onNext: 1A
  D/TAG: emit B
  D/TAG: emit 2
  D/TAG: onNext: 2B
  D/TAG: emit C
  D/TAG: emit 3
  D/TAG: onNext: 3C
  D/TAG: emit complete2
  D/TAG: onComplete

GIF图:

zip
zip

这下就对了嘛, 两根水管同时开始发送, 每发送一个, Zip就组合一个, 再将组合结果发送给下游.
不对呀! 可能细心点的朋友又看出端倪了, 第一根水管明明发送了四个数据+一个Complete, 之前明明还有的, 为啥到这里没了呢?
这是因为我们之前说了, zip发送的事件数量跟上游中发送事件最少的那一根水管的事件数量是有关的, 在这个例子里我们第二根水管只发送了三个事件然后就发送了Complete, 这个时候尽管第一根水管还有事件4事件Complete 没有发送, 但是它们发不发送还有什么意义呢? 所以本着节约是美德的思想, 就干脆打断它的狗腿, 不让它发了.
至于前面的例子为什么会发送, 刚才不是已经说了是!在!同!一!个!线!程!里!吗!!!!再问老子打死你!
有好事的程序员可能又要问了, 那我不发送Complete呢? 答案是显然的, 上游会继续发送事件, 但是下游仍然收不到那些多余的事件. 不信你可以试试.

实践

学习了Zip的基本用法, 那么它在Android有什么用呢, 其实很多场景都可以用到Zip. 举个例子.
比如一个界面需要展示用户的一些信息, 而这些信息分别要从两个服务器接口中获取, 而只有当两个都获取到了之后才能进行展示, 这个时候就可以用Zip了:
首先分别定义这两个请求接口:

  public interface Api {
      @GET
      Observable<UserBaseInfoResponse> getUserBaseInfo(@Body UserBaseInfoRequest request);

      @GET
      Observable<UserExtraInfoResponse> getUserExtraInfo(@Body UserExtraInfoRequest request);

  }

接着用Zip来打包请求:

  Observable<UserBaseInfoResponse> observable1 =
          api.getUserBaseInfo(new UserBaseInfoRequest()).subscribeOn(Schedulers.io());

  Observable<UserExtraInfoResponse> observable2 =
          api.getUserExtraInfo(new UserExtraInfoRequest()).subscribeOn(Schedulers.io());

  Observable.zip(observable1, observable2,
          new BiFunction<UserBaseInfoResponse, UserExtraInfoResponse, UserInfo>() {
              @Override
              public UserInfo apply(UserBaseInfoResponse baseInfo,
                                    UserExtraInfoResponse extraInfo) throws Exception {
                  return new UserInfo(baseInfo, extraInfo);
              }
          }).observeOn(AndroidSchedulers.mainThread())
          .subscribe(new Consumer<UserInfo>() {
              @Override
              public void accept(UserInfo userInfo) throws Exception {
                  //do something;
              }
          });

本次的教程就到这里吧.下一节我们将会学到 Flowable 以及理解Backpressure背压的概念.

第五式 潜龙勿用

概述

这一节中我们将来学习Backpressure. 我看好多吃瓜群众早已坐不住了, 别急, 我们先来回顾一下上一节讲的Zip.

正文

上一节中我们说到Zip可以将多个上游发送的事件组合起来发送给下游, 那大家有没有想过一个问题, 如果其中一个水管A发送事件特别快, 而另一个水管B发送事件特别慢, 那就可能出现这种情况, 发得快的水管A 已经发送了1000个事件了, 而发的慢的水管B 才发一个出来, 组合了一个之后水管A 还剩999个事件, 这些事件需要继续等待水管B 发送事件出来组合, 那么这么多的事件是放在哪里的呢? 总有一个地方保存吧? 没错, Zip给我们的每一根水管都弄了一个水缸 , 用来保存这些事件, 用通俗易懂的图片来表示就是:

zip
zip

如图中所示, 其中蓝色的框框就是zip给我们的水缸! 它将每根水管发出的事件保存起来, 等两个水缸都有事件了之后就分别从水缸中取出一个事件来组合, 当其中一个水缸是空的时候就处于等待的状态.
题外话: 大家来分析一下这个水缸有什么特点呢? 它是按顺序保存的, 先进来的事件先取出来, 这个特点是不是很熟悉呀? 没错, 这就是我们熟知的队列, 这个水缸在Zip内部的实现就是用的队列, 感兴趣的可以翻看源码查看.
好了回到正题上来, 这个水缸有大小限制吗? 要是一直往里存会怎样? 我们来看个例子:

  Observable<Integer> observable1 = Observable.create(new ObservableOnSubscribe<Integer>() {
      @Override
      public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
          for (int i = 0; ; i++) {   //无限循环发事件
              emitter.onNext(i);
          }
      }
  }).subscribeOn(Schedulers.io());

  Observable<String> observable2 = Observable.create(new ObservableOnSubscribe<String>() {
      @Override
      public void subscribe(ObservableEmitter<String> emitter) throws Exception {
          emitter.onNext("A");
      }
  }).subscribeOn(Schedulers.io());

  Observable.zip(observable1, observable2, new BiFunction<Integer, String, String>() {
      @Override
      public String apply(Integer integer, String s) throws Exception {
          return integer + s;
      }
  }).observeOn(AndroidSchedulers.mainThread()).subscribe(new Consumer<String>() {
      @Override
      public void accept(String s) throws Exception {
          Log.d(TAG, s);
      }
  }, new Consumer<Throwable>() {
      @Override
      public void accept(Throwable throwable) throws Exception {
          Log.w(TAG, throwable);
      }
  });

在这个例子中, 我们分别创建了两根水管, 第一根水管用机器指令的执行速度来无限循环发送事件, 第二根水管随便发送点什么, 由于我们没有发送Complete事件, 因此第一根水管会一直发事件到它对应的水缸里去, 我们来看看运行结果是什么样.
运行结果GIF图:

zip
zip

内存占用以斜率为1的直线迅速上涨, 几秒钟就300多M , 最终报出了OOM:

  zlc.season.rxjava2demo W/art: Throwing OutOfMemoryError "Failed to allocate a 28 byte allocation with
  4194304 free bytes and 8MB until OOM;
  zlc.season.rxjava2demo W/art: "main" prio=5 tid=1 Runnable
  zlc.season.rxjava2demo W/art:   | group="main" sCount=0 dsCount=0 obj=0x75188710 self=0x7fc0efe7ba00
  zlc.season.rxjava2demo W/art:   | sysTid=32686 nice=0 cgrp=default sched=0/0 handle=0x7fc0f37dc200
  zlc.season.rxjava2demo W/art:   | state=R schedstat=( 0 0 0 ) utm=948 stm=120 core=1 HZ=100
  zlc.season.rxjava2demo W/art:   | stack=0x7fff971e8000-0x7fff971ea000 stackSize=8MB
  zlc.season.rxjava2demo W/art:   | held mutexes= "mutator lock"(shared held)
  zlc.season.rxjava2demo W/art:     at java.lang.Integer.valueOf(Integer.java:742)

出现这种情况肯定是我们不想看见的, 这里就可以引出我们的Backpressure了, 所谓的Backpressure其实就是为了控制流量, 水缸存储的能力毕竟有限, 因此我们还得从源头去解决问题, 既然你发那么快, 数据量那么大, 那我就想办法不让你发那么快呗.
那么这个源头到底在哪里, 究竟什么时候会出现这种情况, 这里只是说的Zip这一个例子, 其他的地方会出现吗? 带着这个问题我们来探究一下.
我们让事情变得简单一点, 从一个单一的Observable说起.
来看段代码:

  Observable.create(new ObservableOnSubscribe<Integer>() {
      @Override
      public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
          for (int i = 0; ; i++) {   //无限循环发事件
              emitter.onNext(i);
          }
      }
  }).subscribe(new Consumer<Integer>() {
      @Override
      public void accept(Integer integer) throws Exception {
          Thread.sleep(2000);
          Log.d(TAG, "" + integer);
      }
  });

这段代码很简单, 上游同样无限循环的发送事件, 在下游每次接收事件前延时2秒. 上下游工作在同一个线程里, 来看下运行结果:

5.3
5.3

怎么如此平静, 感觉像是走错了片场.
为什么呢, 因为上下游工作在同一个线程呀骚年们! 这个时候上游每次调用emitter.onNext(i)其实就相当于直接调用了Consumer中的:

  public void accept(Integer integer) throws Exception {
      Thread.sleep(2000);
      Log.d(TAG, "" + integer);
  }

所以这个时候其实就是上游每延时2秒发送一次. 最终的结果也说明了这一切.
那我们加个线程呢, 改成这样:

  Observable.create(new ObservableOnSubscribe<Integer>() {
      @Override
      public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
          for (int i = 0; ; i++) {    //无限循环发事件
              emitter.onNext(i);
          }
      }
  }).subscribeOn(Schedulers.io())
          .observeOn(AndroidSchedulers.mainThread())
          .subscribe(new Consumer<Integer>() {
              @Override
              public void accept(Integer integer) throws Exception {
                  Thread.sleep(2000);
                  Log.d(TAG, "" + integer);
              }
          });

这个时候把上游切换到了IO线程中去, 下游到主线程去接收, 来看看运行结果呢:

5.4
5.4

可以看到, 给上游加了个线程之后, 它就像脱缰的野马一样, 内存又爆掉了.
为什么不加线程和加上线程区别这么大呢, 这就涉及了同步和异步的知识了.
当上下游工作在同一个线程中时, 这时候是一个同步的订阅关系, 也就是说上游每发送一个事件必须等到下游接收处理完了以后才能接着发送下一个事件.
当上下游工作在不同的线程中时, 这时候是一个异步的订阅关系, 这个时候上游发送数据不需要等待下游接收, 为什么呢, 因为两个线程并不能直接进行通信, 因此上游发送的事件并不能直接到下游里去, 这个时候就需要一个田螺姑娘来帮助它们俩, 这个田螺姑娘就是我们刚才说的水缸 ! 上游把事件发送到水缸里去, 下游从水缸里取出事件来处理, 因此, 当上游发事件的速度太快, 下游取事件的速度太慢, 水缸就会迅速装满, 然后溢出来, 最后就OOM了.
这两种情况用图片来表示如下:
同步:

同步
同步

异步:
异步
异步

从图中我们可以看出, 同步和异步的区别仅仅在于是否有水缸.
相信通过这个例子大家对线程之间的通信也有了比较清楚的认知和理解.
源头找到了, 只要有水缸, 就会出现上下游发送事件速度不平衡的情况, 因此当我们以后遇到*时, 仔细思考一下水缸在哪里, 找到水缸, 你就找到了解决问题的办法.
既然源头找到了, 那么下一节我们就要来学习如何去解决了.

第六式 利涉大川

概述

在上一节中, 我们找到了上下游流速不均衡的源头 , 在这一节里我们将学习如何去治理它 . 可能很多看过其他人写的文章的朋友都会觉得只有Flowable才能解决 , 所以大家对这个Flowable都抱有很大的期许, 其实呐 , 你们毕竟图样图森破 , 今天我们先抛开Flowable, 仅仅依靠我们自己的双手和智慧 , 来看看我们如何去治理 , 通过本节的学习之后我们再来看Flowable, 你会发现它其实并没有想象中那么牛叉, 它只是被其他人过度神化了.

正文

我们接着来看上一节的这个例子:

  Observable.create(new ObservableOnSubscribe<Integer>() {
      @Override
      public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
          for (int i = 0; ; i++) {  //无限循环发送事件
              emitter.onNext(i);
          }
      }
  }).subscribeOn(Schedulers.io())
          .observeOn(AndroidSchedulers.mainThread())
          .subscribe(new Consumer<Integer>() {
              @Override
              public void accept(Integer integer) throws Exception {
                  Log.d(TAG, "" + integer);
              }
          });

上一节中我们看到了它的运行结果是直接爆掉了内存, 也明白它为什么就爆掉了内存, 那么我们能做些什么, 才能不让这种情况发生呢.
之前我们说了, 上游发送的所有事件都放到水缸里了, 所以瞬间水缸就满了, 那我们可以只放我们需要的事件到水缸里呀, 只放一部分数据到水缸里, 这样不就不会溢出来了吗, 因此, 我们把上面的代码修改一下:

  Observable.create(new ObservableOnSubscribe<Integer>() {
      @Override
      public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
          for (int i = 0; ; i++) {
              emitter.onNext(i);
          }
      }
  }).subscribeOn(Schedulers.io())
          .filter(new Predicate<Integer>() {
              @Override
              public boolean test(Integer integer) throws Exception {
                  return integer % 10 == 0;
              }
          })
          .observeOn(AndroidSchedulers.mainThread())
          .subscribe(new Consumer<Integer>() {
              @Override
              public void accept(Integer integer) throws Exception {
                  Log.d(TAG, "" + integer);
              }
          });

在这段代码中我们增加了一个filter, 只允许能被10整除的事件通过, 再来看看运行结果:

filter
filter

可以看到, 虽然内存依然在增长, 但是增长速度相比之前, 已经减少了太多了, 至少在我录完GIF之前还没有爆掉内存, 大家可以试着改成能被100整除试试.
可以看到, 通过减少进入水缸的事件数量的确可以缓解上下游流速不均衡的问题, 但是力度还不够, 我们再来看一段代码:

  Observable.create(new ObservableOnSubscribe<Integer>() {
      @Override
      public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
          for (int i = 0; ; i++) {
              emitter.onNext(i);
          }
      }
  }).subscribeOn(Schedulers.io())
          .sample(2, TimeUnit.SECONDS)  //sample取样
          .observeOn(AndroidSchedulers.mainThread())
          .subscribe(new Consumer<Integer>() {
              @Override
              public void accept(Integer integer) throws Exception {
                  Log.d(TAG, "" + integer);
              }
          });

这里用了一个sample操作符, 简单做个介绍, 这个操作符每隔指定的时间就从上游中取出一个事件发送给下游. 这里我们让它每隔2秒取一个事件给下游, 来看看这次的运行结果吧:

sample
sample

这次我们可以看到, 虽然上游仍然一直在不停的发事件, 但是我们只是每隔一定时间取一个放进水缸里, 并没有全部放进水缸里, 因此这次内存仅仅只占用了5M.

大家以后可以出去吹牛逼了: 我曾经通过技术手段去优化一个程序, 最终使得内存占用从300多M变成不到5M. ~(≧▽≦)/~

前面这两种方法归根到底其实就是减少放进水缸的事件的数量, 是以数量取胜, 但是这个方法有个缺点, 就是丢失了大部分的事件.
那么我们换一个角度来思考, 既然上游发送事件的速度太快, 那我们就适当减慢发送事件的速度, 从速度上取胜, 听上去不错, 我们来试试:

  Observable.create(new ObservableOnSubscribe<Integer>() {
      @Override
      public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
          for (int i = 0; ; i++) {
              emitter.onNext(i);
              Thread.sleep(2000);  //每次发送完事件延时2秒
          }
      }
  }).subscribeOn(Schedulers.io())
          .observeOn(AndroidSchedulers.mainThread())
          .subscribe(new Consumer<Integer>() {
              @Override
              public void accept(Integer integer) throws Exception {
                  Log.d(TAG, "" + integer);
              }
          });

这次我们让上游每次发送完事件后都延时了2秒, 来看看运行结果:

sleep
sleep

完美 ! 一切都是那么完美 !
可以看到, 我们给上游加上延时了之后, 瞬间一头发情的公牛就变得跟只小绵羊一样, 如此温顺, 如此平静, 如此平稳的内存线, 美妙极了. 而且事件也没有丢失, 上游通过适当的延时, 不但减缓了事件进入水缸的速度, 也可以让下游有充足的时间从水缸里取出事件来处理 , 这样一来, 就不至于导致大量的事件涌进水缸, 也就不会OOM啦.
到目前为止, 我们没有依靠任何其他的工具, 就轻易解决了上下游流速不均衡的问题.
因此我们总结一下, 本节中的治理的办法就两种:

  • 一是从数量上进行治理, 减少发送进水缸里的事件
  • 二是从速度上进行治理, 减缓事件发送进水缸的速度

大家一定没忘记, 在上一节还有个Zip的例子, 这个例子也爆了我们的内存, 现学现用, 我们用刚学到的办法来试试能不能惩奸除恶, 先来看看第一种办法.
先来减少进入水缸的事件的数量:

  Observable<Integer> observable1 = Observable.create(new ObservableOnSubscribe<Integer>() {
      @Override
      public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
          for (int i = 0; ; i++) {
              emitter.onNext(i);
          }
      }
  }).subscribeOn(Schedulers.io()).sample(2, TimeUnit.SECONDS); //进行sample采样

  Observable<String> observable2 = Observable.create(new ObservableOnSubscribe<String>() {
      @Override
      public void subscribe(ObservableEmitter<String> emitter) throws Exception {
          emitter.onNext("A");
      }
  }).subscribeOn(Schedulers.io());

  Observable.zip(observable1, observable2, new BiFunction<Integer, String, String>() {
      @Override
      public String apply(Integer integer, String s) throws Exception {
          return integer + s;
      }
  }).observeOn(AndroidSchedulers.mainThread()).subscribe(new Consumer<String>() {
      @Override
      public void accept(String s) throws Exception {
          Log.d(TAG, s);
      }
  }, new Consumer<Throwable>() {
      @Override
      public void accept(Throwable throwable) throws Exception {
          Log.w(TAG, throwable);
      }
  });

来试试运行结果吧:

zip_sample
zip_sample

哈哈, 成功了吧, 再来用第二种办法试试.
这次我们来减缓速度:

  Observable<Integer> observable1 = Observable.create(new ObservableOnSubscribe<Integer>() {
      @Override
      public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
          for (int i = 0; ; i++) {
              emitter.onNext(i);
              Thread.sleep(2000);  //发送事件之后延时2秒
          }
      }
  }).subscribeOn(Schedulers.io());

  Observable<String> observable2 = Observable.create(new ObservableOnSubscribe<String>() {
      @Override
      public void subscribe(ObservableEmitter<String> emitter) throws Exception {
          emitter.onNext("A");
      }
  }).subscribeOn(Schedulers.io());

  Observable.zip(observable1, observable2, new BiFunction<Integer, String, String>() {
      @Override
      public String apply(Integer integer, String s) throws Exception {
          return integer + s;
      }
  }).observeOn(AndroidSchedulers.mainThread()).subscribe(new Consumer<String>() {
      @Override
      public void accept(String s) throws Exception {
          Log.d(TAG, s);
      }
  }, new Consumer<Throwable>() {
      @Override
      public void accept(Throwable throwable) throws Exception {
          Log.w(TAG, throwable);
      }
  });

来看看运行结果吧:

zip_sleep
zip_sleep

果然也成功了, 这里只打印出了下游收到的事件, 所以只有一个. 如果你对这个结果看不懂, 请自觉掉头看前面几篇文章.
通过本节的学习, 大家应该对如何处理上下游流速不均衡已经有了基本的认识了, 大家也可以看到, 我们并没有使用Flowable, 所以很多时候仔细去分析问题, 找到问题的原因, 从源头去解决才是最根本的办法. 后面我们讲到Flowable的时候, 大家就会发现它其实没什么神秘的, 它用到的办法和我们本节所讲的基本上是一样的, 只是它稍微做了点封装.
好了, 今天的教程就到这里吧, 下一节中我们就会来学习你们喜闻乐见的Flowable.

第七式 震惊百里

概述

上一节里我们学习了只使用Observable如何去解决上下游流速不均衡的问题, 之所以学习这个是因为Observable还是有很多它使用的场景, 有些朋友自从听说了Flowable之后就觉得Flowable能解决任何问题, 甚至有抛弃Observable这种想法, 这是万万不可的, 它们都有各自的优势和不足.
在这一节里我们先来学习如何使用Flowable, 它东西比较多, 也比较繁琐, 解释起来也比较麻烦, 但我还是尽量用通俗易懂的话来说清楚, 毕竟, 这是一个通俗易懂的教程.

正文

我们还是以两根水管举例子:

7.1
7.1

之前我们所的上游和下游分别是ObservableObserver, 这次不一样的是上游变成了Flowable, 下游变成了Subscriber, 但是水管之间的连接还是通过 subscribe(), 我们来看看最基本的用法吧:

  Flowable<Integer> upstream = Flowable.create(new FlowableOnSubscribe<Integer>() {
      @Override
      public void subscribe(FlowableEmitter<Integer> emitter) throws Exception {
          Log.d(TAG, "emit 1");
          emitter.onNext(1);
          Log.d(TAG, "emit 2");
          emitter.onNext(2);
          Log.d(TAG, "emit 3");
          emitter.onNext(3);
          Log.d(TAG, "emit complete");
          emitter.onComplete();
      }
  }, BackpressureStrategy.ERROR); //增加了一个参数

  Subscriber<Integer> downstream = new Subscriber<Integer>() {
      @Override
      public void onSubscribe(Subscription s) {
          Log.d(TAG, "onSubscribe");
          s.request(Long.MAX_VALUE);  //注意这句代码
      }

      @Override
      public void onNext(Integer integer) {
          Log.d(TAG, "onNext: " + integer);
      }

      @Override
      public void onError(Throwable t) {
          Log.w(TAG, "onError: ", t);
      }

      @Override
      public void onComplete() {
          Log.d(TAG, "onComplete");
      }
  };

  upstream.subscribe(downstream);

这段代码中,分别创建了一个上游Flowable和下游Subscriber, 上下游工作在同一个线程中, 和之前的Observable的使用方式只有一点点的区别, 先来看看运行结果吧:

  D/TAG: onSubscribe
  D/TAG: emit 1
  D/TAG: onNext: 1
  D/TAG: emit 2
  D/TAG: onNext: 2
  D/TAG: emit 3
  D/TAG: onNext: 3
  D/TAG: emit complete
  D/TAG: onComplete

结果也和我们预期的是一样的.
我们注意到这次和Observable有些不同. 首先是创建Flowable的时候增加了一个参数, 这个参数是用来选择背压,也就是出现上下游流速不均衡的时候应该怎么处理的办法, 这里我们直接用BackpressureStrategy.ERROR这种方式, 这种方式会在出现上下游流速不均衡的时候直接抛出一个异常,这个异常就是著名的MissingBackpressureException. 其余的策略后面再来讲解.
另外的一个区别是在下游的onSubscribe方法中传给我们的不再是Disposable了, 而是Subscription, 它俩有什么区别呢, 首先它们都是上下游中间的一个开关, 之前我们说调用 Disposable.dispose()方法可以切断水管, 同样的调用 Subscription.cancel()也可以切断水管, 不同的地方在于Subscription增加了一个 void request(long n)方法, 这个方法有什么用呢, 在上面的代码中也有这么一句代码:

 s.request(Long.MAX_VALUE);

这句代码有什么用呢, 不要它可以吗? 我们来试试:

  Flowable.create(new FlowableOnSubscribe<Integer>() {
      @Override
      public void subscribe(FlowableEmitter<Integer> emitter) throws Exception {
          Log.d(TAG, "emit 1");
          emitter.onNext(1);
          Log.d(TAG, "emit 2");
          emitter.onNext(2);
          Log.d(TAG, "emit 3");
          emitter.onNext(3);
          Log.d(TAG, "emit complete");
          emitter.onComplete();
      }
  }, BackpressureStrategy.ERROR).subscribe(new Subscriber<Integer>() {

      @Override
      public void onSubscribe(Subscription s) {
          Log.d(TAG, "onSubscribe");
      }

      @Override
      public void onNext(Integer integer) {
          Log.d(TAG, "onNext: " + integer);
      }

      @Override
      public void onError(Throwable t) {
          Log.w(TAG, "onError: ", t);
      }

      @Override
      public void onComplete() {
          Log.d(TAG, "onComplete");
      }
  });

这次我们取消掉了request这句代码, 来看看运行结果:

  zlc.season.rxjava2demo D/TAG: onSubscribe
  zlc.season.rxjava2demo D/TAG: emit 1
  zlc.season.rxjava2demo W/TAG: onError:
                                io.reactivex.exceptions.MissingBackpressureException: create: could not emit value due to lack of requests
                                    at io.reactivex.internal.operators.flowable.FlowableCreate$ErrorAsyncEmitter.onOverflow(FlowableCreate.java:411)
                                    at io.reactivex.internal.operators.flowable.FlowableCreate$NoOverflowBaseAsyncEmitter.onNext(FlowableCreate.java:377)
                                    at zlc.season.rxjava2demo.demo.ChapterSeven$3.subscribe(ChapterSeven.java:77)
                                    at io.reactivex.internal.operators.flowable.FlowableCreate.subscribeActual(FlowableCreate.java:72)
                                    at io.reactivex.Flowable.subscribe(Flowable.java:12218)
                                    at zlc.season.rxjava2demo.demo.ChapterSeven.demo2(ChapterSeven.java:111)
                                    at zlc.season.rxjava2demo.MainActivity$2.onClick(MainActivity.java:36)
                                    at android.view.View.performClick(View.java:5637)
                                    at android.view.View$PerformClick.run(View.java:22429)
                                    at android.os.Handler.handleCallback(Handler.java:751)
                                    at android.os.Handler.dispatchMessage(Handler.java:95)
                                    at android.os.Looper.loop(Looper.java:154)
                                    at android.app.ActivityThread.main(ActivityThread.java:6119)
                                    at java.lang.reflect.Method.invoke(Native Method)
                                    at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:886)
                                    at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:776)
  zlc.season.rxjava2demo D/TAG: emit 2
  zlc.season.rxjava2demo D/TAG: emit 3
  zlc.season.rxjava2demo D/TAG: emit complete

哎哎哎, 大兄弟, 怎么一言不合就抛异常?
从运行结果中可以看到, 在上游发送第一个事件之后, 下游就抛出了一个著名的MissingBackpressureException异常, 并且下游没有收到任何其余的事件. 可是这是一个同步的订阅呀, 上下游工作在同一个线程, 上游每发送一个事件应该会等待下游处理完了才会继续发事件啊, 不可能出现上下游流速不均衡的问题呀.
带着这个疑问, 我们再来看看异步的情况:

  Flowable.create(new FlowableOnSubscribe<Integer>() {
      @Override
      public void subscribe(FlowableEmitter<Integer> emitter) throws Exception {
          Log.d(TAG, "emit 1");
          emitter.onNext(1);
          Log.d(TAG, "emit 2");
          emitter.onNext(2);
          Log.d(TAG, "emit 3");
          emitter.onNext(3);
          Log.d(TAG, "emit complete");
          emitter.onComplete();
      }
  }, BackpressureStrategy.ERROR).subscribeOn(Schedulers.io())
          .observeOn(AndroidSchedulers.mainThread())
          .subscribe(new Subscriber<Integer>() {

              @Override
              public void onSubscribe(Subscription s) {
                  Log.d(TAG, "onSubscribe");
                  mSubscription = s;
              }

              @Override
              public void onNext(Integer integer) {
                  Log.d(TAG, "onNext: " + integer);
              }

              @Override
              public void onError(Throwable t) {
                  Log.w(TAG, "onError: ", t);
              }

              @Override
              public void onComplete() {
                  Log.d(TAG, "onComplete");
              }
          });

这次我们同样去掉了request这句代码, 但是让上下游工作在不同的线程, 来看看运行结果:

  zlc.season.rxjava2demo D/TAG: onSubscribe
  zlc.season.rxjava2demo D/TAG: emit 1
  zlc.season.rxjava2demo D/TAG: emit 2
  zlc.season.rxjava2demo D/TAG: emit 3
  zlc.season.rxjava2demo D/TAG: emit complete

哎, 这次上游正确的发送了所有的事件, 但是下游一个事件也没有收到. 这是因为什么呢?
这是因为Flowable在设计的时候采用了一种新的思路也就是响应式拉取的方式来更好的解决上下游流速不均衡的问题, 与我们之前所讲的控制数量和控制速度不太一样, 这种方式用通俗易懂的话来说就好比是叶问打鬼子, 我们把上游看成小日本, 把下游当作叶问, 当调用 Subscription.request(1) 时, 叶问就说我要打一个! 然后小日本就拿出一个鬼子给叶问, 让他打, 等叶问打死这个鬼子之后, 再次调用 request(10), 叶问就又说我要打十个! 然后小日本又派出十个鬼子给叶问, 然后就在边上看热闹, 看叶问能不能打死十个鬼子, 等叶问打死十个鬼子后再继续要鬼子接着打…
所以我们把request当做是一种能力, 当成下游处理事件的能力, 下游能处理几个就告诉上游我要几个, 这样只要上游根据下游的处理能力来决定发送多少事件, 就不会造成一窝蜂的发出一堆事件来, 从而导致OOM. 这也就完美的解决之前我们所学到的两种方式的缺陷, 过滤事件会导致事件丢失, 减速又可能导致性能损失. 而这种方式既解决了事件丢失的问题, 又解决了速度的问题, 完美 !
但是太完美的东西也就意味着陷阱也会很多, 你可能只是被它的外表所迷惑, 失去了理智, 如果你滥用或者不遵守规则, 一样会吃到苦头.
比如这里需要注意的是, 只有当上游正确的实现了如何根据下游的处理能力来发送事件的时候, 才能达到这种效果, 如果上游根本不管下游的处理能力, 一股脑的瞎他妈发事件, 仍然会产生上下游流速不均衡的问题, 这就好比小日本管他叶问要打几个, 老子直接拿出1万个鬼子, 这尼玛有种打死给我看看? 那么如何正确的去实现上游呢, 这里先卖个关子, 之后我们再来讲解.
学习了request, 我们就可以解释上面的两段代码了.

  • 首先第一个同步的代码, 为什么上游发送第一个事件后下游就抛出了MissingBackpressureException异常, 这是因为下游没有调用request, 上游就认为下游没有处理事件的能力, 而这又是一个同步的订阅, 既然下游处理不了, 那上游不可能一直等待吧, 如果是这样, 万一这两根水管工作在主线程里, 界面不就卡死了吗, 因此只能抛个异常来提醒我们. 那如何解决这种情况呢, 很简单啦, 下游直接调用request(Long.MAX_VALUE)就行了, 或者根据上游发送事件的数量来request就行了, 比如这里request(3)就可以了.
  • 第二段异步代码, 为什么上下游没有工作在同一个线程时, 上游却正确的发送了所有的事件呢? 这是因为在Flowable里默认有一个大小为128的水缸, 当上下游工作在不同的线程中时, 上游就会先把事件发送到这个水缸中, 因此, 下游虽然没有调用request, 但是上游在水缸中保存着这些事件, 只有当下游调用request时, 才从水缸里取出事件发给下游.

是不是这样呢, 我们来验证一下:

  public static void request(long n) {
      mSubscription.request(n); //在外部调用request请求上游
  }

  public static void demo3() {
      Flowable.create(new FlowableOnSubscribe<Integer>() {
          @Override
          public void subscribe(FlowableEmitter<Integer> emitter) throws Exception {
              Log.d(TAG, "emit 1");
              emitter.onNext(1);
              Log.d(TAG, "emit 2");
              emitter.onNext(2);
              Log.d(TAG, "emit 3");
              emitter.onNext(3);
              Log.d(TAG, "emit complete");
              emitter.onComplete();
          }
      }, BackpressureStrategy.ERROR).subscribeOn(Schedulers.io())
              .observeOn(AndroidSchedulers.mainThread())
              .subscribe(new Subscriber<Integer>() {

                  @Override
                  public void onSubscribe(Subscription s) {
                      Log.d(TAG, "onSubscribe");
                      mSubscription = s;  //把Subscription保存起来
                  }

                  @Override
                  public void onNext(Integer integer) {
                      Log.d(TAG, "onNext: " + integer);
                  }

                  @Override
                  public void onError(Throwable t) {
                      Log.w(TAG, "onError: ", t);
                  }

                  @Override
                  public void onComplete() {
                      Log.d(TAG, "onComplete");
                  }
              });
  }

这里我们把Subscription保存起来, 在界面上增加了一个按钮, 点击一次就调用 Subscription.request(1), 来看看运行结果:

request
request

结果似乎像那么回事, 上游发送了四个事件保存到了水缸里, 下游每request一个, 就接收一个进行处理.
刚刚我们有说到水缸的大小为128, 有朋友就问了, 你说128就128吗, 又不是唯品会周年庆, 我不信. 那就来验证一下:

  Flowable.create(new FlowableOnSubscribe<Integer>() {
      @Override
      public void subscribe(FlowableEmitter<Integer> emitter) throws Exception {
          for (int i = 0; i < 128; i++) {
              Log.d(TAG, "emit " + i);
              emitter.onNext(i);
          }
      }
  }, BackpressureStrategy.ERROR).subscribeOn(Schedulers.io())
          .observeOn(AndroidSchedulers.mainThread())
          .subscribe(new Subscriber<Integer>() {

              @Override
              public void onSubscribe(Subscription s) {
                  Log.d(TAG, "onSubscribe");
                  mSubscription = s;
              }

              @Override
              public void onNext(Integer integer) {
                  Log.d(TAG, "onNext: " + integer);
              }

              @Override
              public void onError(Throwable t) {
                  Log.w(TAG, "onError: ", t);
              }

              @Override
              public void onComplete() {
                  Log.d(TAG, "onComplete");
              }
          });

这里我们让上游一次性发送了128个事件, 下游一个也不接收, 来看看运行结果:

  zlc.season.rxjava2demo D/TAG: onSubscribe
  zlc.season.rxjava2demo D/TAG: emit 0
    ...
  zlc.season.rxjava2demo D/TAG: emit 126
  zlc.season.rxjava2demo D/TAG: emit 127

这段代码的运行结果很正常, 没有任何错误和异常, 上游仅仅是发送了128个事件.
那来试试129个呢, 把上面代码中的128改成129试试:

  zlc.season.rxjava2demo D/TAG: onSubscribe
  zlc.season.rxjava2demo D/TAG: emit 0
    ...
  zlc.season.rxjava2demo D/TAG: emit 126
  zlc.season.rxjava2demo D/TAG: emit 127
  zlc.season.rxjava2demo D/TAG: emit 128  //这是第129个事件
  zlc.season.rxjava2demo W/TAG: onError:
                                io.reactivex.exceptions.MissingBackpressureException: create: could not emit value due to lack of requests
                                    at io.reactivex.internal.operators.flowable.FlowableCreate$ErrorAsyncEmitter.onOverflow(FlowableCreate.java:411)
                                    at io.reactivex.internal.operators.flowable.FlowableCreate$NoOverflowBaseAsyncEmitter.onNext(FlowableCreate.java:377)
                                    at zlc.season.rxjava2demo.demo.ChapterSeven$7.subscribe(ChapterSeven.java:169)
                                    at io.reactivex.internal.operators.flowable.FlowableCreate.subscribeActual(FlowableCreate.java:72)
                                    at io.reactivex.Flowable.subscribe(Flowable.java:12218)
                                    at io.reactivex.internal.operators.flowable.FlowableSubscribeOn$SubscribeOnSubscriber.run(FlowableSubscribeOn.java:82)
                                    at io.reactivex.internal.schedulers.ScheduledRunnable.run(ScheduledRunnable.java:59)
                                    at io.reactivex.internal.schedulers.ScheduledRunnable.call(ScheduledRunnable.java:51)
                                    at java.util.concurrent.FutureTask.run(FutureTask.java:237)
                                    at java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.run(ScheduledThreadPoolExecutor.java:272)
                                    at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1133)
                                    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:607)
                                    at java.lang.Thread.run(Thread.java:761)

这次可以看到, 在上游发送了第129个事件的时候, 就抛出了MissingBackpressureException异常, 提醒我们发洪水啦. 当然了, 这个128也不是我凭空捏造出来的, Flowable的源码中就有这个buffersize的大小定义, 可以自行查看.
注意这里我们是把上游发送的事件全部都存进了水缸里, 下游一个也没有消费, 所以就溢出了, 如果下游去消费了事件, 可能就不会导致水缸溢出来了. 这里我们说的是可能不会, 这也很好理解, 比如刚才这个例子上游发了129个事件, 下游只要快速的消费了一个事件, 就不会溢出了, 但如果下游过了十秒钟再来消费一个, 那肯定早就溢出了.
好了, 今天的教程就到这里了, 下一节我们将会更加深入的去学习FLowable, 敬请期待.
(哈哈, 给我的RxDownload打个广告: RxDownload是一个基于RxJava的多线程+断点续传的下载工具, 感兴趣的来GitHub点个star吧☺. 电梯直达->戳这里 )

第八式 或跃在渊

概述

在上一节中, 我们学习了FLowable的一些基本知识, 同时也挖了许多坑, 这一节就让我们来填坑吧.

正文

上一节中最后我们有个例子, 当上游一次性发送128个事件的时候是没有任何问题的, 一旦超过128就会抛出MissingBackpressureException异常, 提示你上游发太多事件了, 下游处理不过来, 那么怎么去解决呢?
我们先来思考一下, 发送128个事件没有问题是因为FLowable内部有一个大小为128的水缸, 超过128就会装满溢出来, 那既然你水缸这么小, 那我给你换一个大水缸如何, 听上去很有道理的样子, 来试试:

  Flowable.create(new FlowableOnSubscribe<Integer>() {
      @Override
      public void subscribe(FlowableEmitter<Integer> emitter) throws Exception {
          for (int i = 0; i < 1000; i++) {
              Log.d(TAG, "emit " + i);
              emitter.onNext(i);
          }
      }
  }, BackpressureStrategy.BUFFER).subscribeOn(Schedulers.io())
          .observeOn(AndroidSchedulers.mainThread())
          .subscribe(new Subscriber<Integer>() {

              @Override
              public void onSubscribe(Subscription s) {
                  Log.d(TAG, "onSubscribe");
                  mSubscription = s;
              }

              @Override
              public void onNext(Integer integer) {
                  Log.d(TAG, "onNext: " + integer);
              }

              @Override
              public void onError(Throwable t) {
                  Log.w(TAG, "onError: ", t);
              }

              @Override
              public void onComplete() {
                  Log.d(TAG, "onComplete");
              }
          });

这次我们直接让上游发送了1000个事件,下游仍然不调用request去请求, 与之前不同的是, 这次我们用的策略是BackpressureStrategy.BUFFER, 这就是我们的新水缸啦, 这个水缸就比原来的水缸牛逼多了,如果说原来的水缸是95式步枪, 那这个新的水缸就好比黄金AK , 它没有大小限制, 因此可以存放许许多多的事件.
所以这次的运行结果就是:

  zlc.season.rxjava2demo D/TAG: onSubscribe
  zlc.season.rxjava2demo D/TAG: emit 0
  zlc.season.rxjava2demo D/TAG: emit 1
  zlc.season.rxjava2demo D/TAG: emit 2
  ...
  zlc.season.rxjava2demo D/TAG: emit 997
  zlc.season.rxjava2demo D/TAG: emit 998
  zlc.season.rxjava2demo D/TAG: emit 999

不知道大家有没有发现, 换了水缸的FLowable和Observable好像是一样的嘛…
不错, 这时的FLowable表现出来的特性的确和Observable一模一样, 因此, 如果你像这样单纯的使用FLowable, 同样需要注意OOM的问题, 例如下面这个例子:

  Flowable.create(new FlowableOnSubscribe<Integer>() {
      @Override
      public void subscribe(FlowableEmitter<Integer> emitter) throws Exception {
          for (int i = 0; ; i++) {
              emitter.onNext(i);
          }
      }
  }, BackpressureStrategy.BUFFER).subscribeOn(Schedulers.io())
          .observeOn(AndroidSchedulers.mainThread())
          .subscribe(new Subscriber<Integer>() {

              @Override
              public void onSubscribe(Subscription s) {
                  Log.d(TAG, "onSubscribe");
                  mSubscription = s;
              }

              @Override
              public void onNext(Integer integer) {
                  Log.d(TAG, "onNext: " + integer);
              }

              @Override
              public void onError(Throwable t) {
                  Log.w(TAG, "onError: ", t);
              }

              @Override
              public void onComplete() {
                  Log.d(TAG, "onComplete");
              }
          });

按照我们以前学习Observable一样, 让上游无限循环发送事件, 下游一个也不去处理, 来看看运行结果吧:

flowable
flowable

同样可以看到, 内存迅速增长, 直到最后抛出OOM. 所以说不要迷恋FLowable, 它只是个传说.

可能有朋友也注意到了, 之前使用Observable测试的时候内存增长非常迅速, 几秒钟就OOM, 但这里增长速度却比较缓慢, 可以翻回去看之前的文章中的GIF图进行对比, 这也看出FLowable相比Observable, 在性能方面有些不足, 毕竟FLowable内部为了实现响应式拉取做了更多的操作, 性能有所丢失也是在所难免, 因此单单只是说因为FLowable是新兴产物就盲目的使用也是不对的, 也要具体分场景,

那除了给FLowable换一个大水缸还有没有其他的办法呢, 因为更大的水缸也只是缓兵之计啊, 动不动就OOM给你看.
想想看我们之前学习Observable的时候说到的如何解决上游发送事件太快的, 有一招叫从数量上取胜, 同样的FLowable中也有这种方法, 对应的就是 BackpressureStrategy.DROPBackpressureStrategy.LATEST 这两种策略.
从名字上就能猜到它俩是干啥的, Drop 就是直接把存不下的事件 丢弃, Latest 就是只保留最新的事件, 来看看它们的实际效果吧.
先来看看Drop:

  public static void request() {
      mSubscription.request(128);
  }

  public static void demo3() {
      Flowable.create(new FlowableOnSubscribe<Integer>() {
          @Override
          public void subscribe(FlowableEmitter<Integer> emitter) throws Exception {
              for (int i = 0; ; i++) {
                  emitter.onNext(i);
              }
          }
      }, BackpressureStrategy.DROP).subscribeOn(Schedulers.io())
              .observeOn(AndroidSchedulers.mainThread())
              .subscribe(new Subscriber<Integer>() {

                  @Override
                  public void onSubscribe(Subscription s) {
                      Log.d(TAG, "onSubscribe");
                      mSubscription = s;
                  }

                  @Override
                  public void onNext(Integer integer) {
                      Log.d(TAG, "onNext: " + integer);
                  }

                  @Override
                  public void onError(Throwable t) {
                      Log.w(TAG, "onError: ", t);
                  }

                  @Override
                  public void onComplete() {
                      Log.d(TAG, "onComplete");
                  }
              });
  }

我们仍然让上游无限循环发送事件, 这次的策略选择了Drop, 同时把Subscription保存起来, 待会我们在外部调用 request(128) 时, 便可以看到运行的结果.
我们先来猜一下运行结果, 这里为什么request(128)呢, 因为之前不是已经说了吗, FLowable内部的默认的水缸大小为128, 因此, 它刚开始肯定会把0-127这128个事件保存起来, 然后丢弃掉其余的事件, 当我们request(128)的时候,下游便会处理掉这128个事件, 那么上游水缸中又会重新装进新的128个事件, 以此类推, 来看看运行结果吧:

drop
drop

从运行结果中我们看到的确是如此, 第一次request的时候, 下游的确收到的是0-127这128个事件, 但第二次request的时候就不确定了, 因为上游一直在发送事件. 内存占用也很正常, drop的作用相信大家也很清楚了.
再来看看Latest吧:

  public static void request() {
      mSubscription.request(128);
  }

  public static void demo4() {
      Flowable.create(new FlowableOnSubscribe<Integer>() {
          @Override
          public void subscribe(FlowableEmitter<Integer> emitter) throws Exception {
              for (int i = 0; ; i++) {
                  emitter.onNext(i);
              }
          }
      }, BackpressureStrategy.LATEST).subscribeOn(Schedulers.io())
              .observeOn(AndroidSchedulers.mainThread())
              .subscribe(new Subscriber<Integer>() {

                  @Override
                  public void onSubscribe(Subscription s) {
                      Log.d(TAG, "onSubscribe");
                      mSubscription = s;
                  }

                  @Override
                  public void onNext(Integer integer) {
                      Log.d(TAG, "onNext: " + integer);
                  }

                  @Override
                  public void onError(Throwable t) {
                      Log.w(TAG, "onError: ", t);
                  }

                  @Override
                  public void onComplete() {
                      Log.d(TAG, "onComplete");
                  }
              });
  }

同样的, 上游无限循环发送事件, 策略选择 Latest , 同时把Subscription保存起来, 方便在外部调用request(128).来看看这次的运行结果:

latest
latest

诶, 看上去好像和Drop差不多啊, Latest也首先保存了0-127这128个事件, 等下游把这128个事件处理了之后才进行之后的处理, 光从这里没有看出有任何区别啊…

古人云,师者,所以传道受业解惑也。人非生而知之者,孰能无惑?惑而不从师,其为惑也,终不解矣.

作为初学者的入门导师, 是不能给大家留下一点点疑惑的, 来让我们继续揭开这个疑问.
我们把上面两段代码改良一下, 先来看看DROP的改良版:

  Flowable.create(new FlowableOnSubscribe<Integer>() {
      @Override
      public void subscribe(FlowableEmitter<Integer> emitter) throws Exception {
          for (int i = 0; i < 10000; i++) {  //只发1w个事件
              emitter.onNext(i);
          }
      }
  }, BackpressureStrategy.DROP).subscribeOn(Schedulers.io())
          .observeOn(AndroidSchedulers.mainThread())
          .subscribe(new Subscriber<Integer>() {

              @Override
              public void onSubscribe(Subscription s) {
                  Log.d(TAG, "onSubscribe");
                  mSubscription = s;
                  s.request(128);  //一开始就处理掉128个事件
              }

              @Override
              public void onNext(Integer integer) {
                  Log.d(TAG, "onNext: " + integer);
              }

              @Override
              public void onError(Throwable t) {
                  Log.w(TAG, "onError: ", t);
              }

              @Override
              public void onComplete() {
                  Log.d(TAG, "onComplete");
              }
          });

这段代码和之前有两点不同, 一是上游只发送了10000个事件, 二是下游在一开始就立马处理掉了128个事件, 然后我们在外部再调用request(128)试试, 来看看运行结果:

drop
drop

这次可以看到, 一开始下游就处理掉了128个事件, 当我们再次request的时候, 只得到了第3317的事件, 后面的事件直接被抛弃了.
再来看看Latest的运行结果吧:

latest
latest

从运行结果中可以看到, 除去前面128个事件, 与Drop不同, Latest总是能获取到最后最新的事件, 例如这里我们总是能获得最后一个事件9999.
好了, 关于FLowable的策略我们也讲完了, 有些朋友要问了, 这些FLowable是我自己创建的, 所以我可以选择策略, 那面对有些FLowable并不是我自己创建的, 该怎么办呢? 比如RxJava中的interval操作符, 这个操作符并不是我们自己创建的, 来看下面这个例子吧:

  Flowable.interval(1, TimeUnit.MICROSECONDS)
          .observeOn(AndroidSchedulers.mainThread())
          .subscribe(new Subscriber<Long>() {
              @Override
              public void onSubscribe(Subscription s) {
                  Log.d(TAG, "onSubscribe");
                  mSubscription = s;
                  s.request(Long.MAX_VALUE);
              }

              @Override
              public void onNext(Long aLong) {
                  Log.d(TAG, "onNext: " + aLong);
                  try {
                      Thread.sleep(1000);  //延时1秒
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
              }

              @Override
              public void onError(Throwable t) {
                  Log.w(TAG, "onError: ", t);
              }

              @Override
              public void onComplete() {
                  Log.d(TAG, "onComplete");
              }
          });

interval 操作符发送Long型的事件, 从0开始, 每隔指定的时间就把数字加1并发送出来, 在这个例子里, 我们让它每隔1毫秒就发送一次事件, 在下游延时1秒去接收处理, 不用猜也知道结果是什么:

  zlc.season.rxjava2demo D/TAG: onSubscribe
  zlc.season.rxjava2demo W/TAG: onError:
                                io.reactivex.exceptions.MissingBackpressureException: Can't deliver value 128 due to lack of requests
                                    at io.reactivex.internal.operators.flowable.FlowableInterval$IntervalSubscriber.run(FlowableInterval.java:87)
                                    at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:428)
                                    at java.util.concurrent.FutureTask.runAndReset(FutureTask.java:278)
                                    at java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.run(ScheduledThreadPoolExecutor.java:273)
                                    at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1133)
                                    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:607)
                                    at java.lang.Thread.run(Thread.java:761)

一运行就抛出了MissingBackpressureException异常, 提醒我们发太多了, 那么怎么办呢, 这个又不是我们自己创建的FLowable啊…
别慌, 虽然不是我们自己创建的, 但是RxJava给我们提供了其他的方法:

  • onBackpressureBuffer()
  • onBackpressureDrop()
  • onBackpressureLatest()

熟悉吗? 这跟我们上面学的策略是一样的, 用法也简单, 拿刚才的例子现学现用:

  Flowable.interval(1, TimeUnit.MICROSECONDS)
          .onBackpressureDrop()  //加上背压策略
          .observeOn(AndroidSchedulers.mainThread())
          .subscribe(new Subscriber<Long>() {
              @Override
              public void onSubscribe(Subscription s) {
                  Log.d(TAG, "onSubscribe");
                  mSubscription = s;
                  s.request(Long.MAX_VALUE);
              }

              @Override
              public void onNext(Long aLong) {
                  Log.d(TAG, "onNext: " + aLong);
                  try {
                      Thread.sleep(1000);
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
              }

              @Override
              public void onError(Throwable t) {
                  Log.w(TAG, "onError: ", t);
              }

              @Override
              public void onComplete() {
                  Log.d(TAG, "onComplete");
              }
          });

其余的我就不一一列举了.
好了, 今天的教程就到这里吧, 这一节我们学习了如何使用内置的BackpressureStrategy来解决上下游事件速率不均衡的问题. 这些策略其实之前我们将Observable的时候也提到过, 其实大差不差, 只要理解了为什么会上游发事件太快, 下游处理太慢这一点, 你就好处理了, FLowable无非就是给你封装好了, 确实对初学者友好一点, 但是很多初学者往往只知道How, 却不知道Why, 最重要的其实是知道why, 而不是How.
(其余的教程大多数到这里就结束了, 但是, 你以为FLowable就这么点东西吗, 骚年, Too young too simple, sometimes naive! 这仅仅是开始, 真正牛逼的还没来呢. 敬请关注下一节, 下节见 ! )

第九式 双龙取水

概述

先来回顾一下第七节,我们讲Flowable的时候,说它采用了响应式拉取的方式,我们还举了个叶问打小日本的例子,再来回顾一下吧,我们说把上游看成小日本, 把下游当作叶问, 当调用 Subscription.request(1) 时, 叶问就说我要打一个! 然后小日本就拿出一个鬼子给叶问, 让他打, 等叶问打死这个鬼子之后, 再次调用 request(10), 叶问就又说我要打十个! 然后小日本又派出十个鬼子给叶问, 然后就在边上看热闹, 看叶问能不能打死十个鬼子, 等叶问打死十个鬼子后再继续要鬼子接着打。

正文

但是不知道大家有没有发现,在我们前两节中的例子中,我们口中声称的响应式拉取并没有完全体现出来,比如这个例子:

  Flowable.create(new FlowableOnSubscribe<Integer>() {
      @Override
      public void subscribe(FlowableEmitter<Integer> emitter) throws Exception {
          Log.d(TAG, "emit 1");
          emitter.onNext(1);
          Log.d(TAG, "emit 2");
          emitter.onNext(2);
          Log.d(TAG, "emit 3");
          emitter.onNext(3);
          Log.d(TAG, "emit complete");
          emitter.onComplete();
      }
  }, BackpressureStrategy.ERROR).subscribeOn(Schedulers.io())
          .observeOn(AndroidSchedulers.mainThread())
          .subscribe(new Subscriber<Integer>() {

              @Override
              public void onSubscribe(Subscription s) {
                  Log.d(TAG, "onSubscribe");
                  mSubscription = s;
                  s.request(1);
              }

              @Override
              public void onNext(Integer integer) {
                  Log.d(TAG, "onNext: " + integer);
                  mSubscription.request(1);
              }

              @Override
              public void onError(Throwable t) {
                  Log.w(TAG, "onError: ", t);
              }

              @Override
              public void onComplete() {
                  Log.d(TAG, "onComplete");
              }
          });

虽然我们在下游中是每次处理掉了一个事件之后才调用request(1)去请求下一个事件,也就是说叶问的确是在打死了一个鬼子之后才继续打下一个鬼子,可是上游呢?上游真的是每次当下游请求一个才拿出一个吗?从上上篇文章中我们知道并不是这样的,上游仍然是一开始就发送了所有的事件,也就是说小日本并没有等叶问打死一个才拿出一个,而是一开始就拿出了所有的鬼子,这些鬼子从一开始就在这儿排队等着被打死。
有个故事是这么说的:

楚人有卖盾与矛者,先誉其盾之坚,曰:“吾盾之坚,物莫能陷也。”俄而又誉其矛之利,曰:“吾矛之利,万物莫不陷也。”市人诘之曰:”以子之矛陷子之盾,何如?”其人弗能应也。众皆笑之。

没错,我们前后所说的就是自相矛盾了,这说明了什么呢,说明我们的实现并不是一个完整的实现,那么,究竟怎样的实现才是完整的呢?
我们先自己来想一想,在下游中调用 Subscription.request(n) 就可以告诉上游,下游能够处理多少个事件,那么上游要根据下游的处理能力正确的去发送事件,那么上游是不是应该知道下游的处理能力是多少啊,对吧,不然,一个巴掌拍不响啊,这种事情得你情我愿才行。
那么上游从哪里得知下游的处理能力呢?我们来看看上游最重要的部分,肯定就是 FlowableEmitter 了啊,我们就是通过它来发送事件的啊,来看看它的源码吧(别紧张,它的代码灰常简单):

  public interface FlowableEmitter<T> extends Emitter<T> {
      void setDisposable(Disposable s);
      void setCancellable(Cancellable c);

      /**
       * The current outstanding request amount.
       * <p>This method is thread-safe.
       * @return the current outstanding request amount
       */
      long requested();

      boolean isCancelled();
      FlowableEmitter<T> serialize();
  }

FlowableEmitter 是个接口,继承Emitter ,Emitter里面就是我们的 onNext() , onComplete()onError() 三个方法。我们看到FlowableEmitter中有这么一个方法:

  long requested();

方法注释的意思就是当前外部请求的数量,哇哦,这好像就是我们要找的答案呢. 我们还是实际验证一下吧.
先来看同步的情况吧:

  public static void demo1() {
      Flowable.create(new FlowableOnSubscribe<Integer>() {
                  @Override
                  public void subscribe(FlowableEmitter<Integer> emitter) throws Exception {
                      Log.d(TAG, "current requested: " + emitter.requested());
                  }
              }, BackpressureStrategy.ERROR)
              .subscribe(new Subscriber<Integer>() {

                  @Override
                  public void onSubscribe(Subscription s) {
                      Log.d(TAG, "onSubscribe");
                      mSubscription = s;
                  }

                  @Override
                  public void onNext(Integer integer) {
                      Log.d(TAG, "onNext: " + integer);
                  }

                  @Override
                  public void onError(Throwable t) {
                      Log.w(TAG, "onError: ", t);
                  }

                  @Override
                  public void onComplete() {
                      Log.d(TAG, "onComplete");
                  }
              });
  }

这个例子中,我们在上游中打印出当前的request数量,下游什么也不做。
我们先猜测一下结果,下游没有调用 request(),说明当前下游的处理能力为0,那么上游得到的requested也应该是0,是不是呢?
来看看运行结果:

  D/TAG: onSubscribe
  D/TAG: current requested: 0

哈哈,结果果然是0,说明我们的结论基本上是对的。
那下游要是调用了 request() 呢,来看看:

  public static void demo1() {
      Flowable.create(new FlowableOnSubscribe<Integer>() {
                  @Override
                  public void subscribe(FlowableEmitter<Integer> emitter) throws Exception {
                      Log.d(TAG, "current requested: " + emitter.requested());
                  }
              }, BackpressureStrategy.ERROR)
              .subscribe(new Subscriber<Integer>() {

                  @Override
                  public void onSubscribe(Subscription s) {
                      Log.d(TAG, "onSubscribe");
                      mSubscription = s;
                      s.request(10); //我要打十个!
                  }

                  @Override
                  public void onNext(Integer integer) {
                      Log.d(TAG, "onNext: " + integer);
                  }

                  @Override
                  public void onError(Throwable t) {
                      Log.w(TAG, "onError: ", t);
                  }

                  @Override
                  public void onComplete() {
                      Log.d(TAG, "onComplete");
                  }
              });
  }

这次在下游中调用了 request(10),告诉上游我要打十个,看看运行结果:

  D/TAG: onSubscribe
  D/TAG: current requested: 10

果然!上游的requested的确是根据下游的请求来决定的,那要是下游多次请求呢?比如这样:

  public static void demo1() {
      Flowable.create(new FlowableOnSubscribe<Integer>() {
                  @Override
                  public void subscribe(FlowableEmitter<Integer> emitter) throws Exception {
                      Log.d(TAG, "current requested: " + emitter.requested());
                  }
              }, BackpressureStrategy.ERROR)
              .subscribe(new Subscriber<Integer>() {

                  @Override
                  public void onSubscribe(Subscription s) {
                      Log.d(TAG, "onSubscribe");
                      mSubscription = s;
                      s.request(10);  //我要打十个!
                      s.request(100); //再给我一百个!
                  }

                  @Override
                  public void onNext(Integer integer) {
                      Log.d(TAG, "onNext: " + integer);
                  }

                  @Override
                  public void onError(Throwable t) {
                      Log.w(TAG, "onError: ", t);
                  }

                  @Override
                  public void onComplete() {
                      Log.d(TAG, "onComplete");
                  }
              });
  }

下游先调用了 request(10) , 然后又调用了 request(100) ,来看看运行结果:

  D/TAG: onSubscribe
  D/TAG: current requested: 110

看来多次调用也没问题,做了加法。
诶加法?对哦,只是做加法,那什么时候做减法呢?
当然是发送事件啦!
来看个例子吧:

  public static void demo2() {
      Flowable.create(new FlowableOnSubscribe<Integer>() {
                  @Override
                  public void subscribe(final FlowableEmitter<Integer> emitter) throws Exception {
                      Log.d(TAG, "before emit, requested = " + emitter.requested());

                      Log.d(TAG, "emit 1");
                      emitter.onNext(1);
                      Log.d(TAG, "after emit 1, requested = " + emitter.requested());

                      Log.d(TAG, "emit 2");
                      emitter.onNext(2);
                      Log.d(TAG, "after emit 2, requested = " + emitter.requested());

                      Log.d(TAG, "emit 3");
                      emitter.onNext(3);
                      Log.d(TAG, "after emit 3, requested = " + emitter.requested());

                      Log.d(TAG, "emit complete");
                      emitter.onComplete();

                      Log.d(TAG, "after emit complete, requested = " + emitter.requested());
                  }
              }, BackpressureStrategy.ERROR)
              .subscribe(new Subscriber<Integer>() {

                  @Override
                  public void onSubscribe(Subscription s) {
                      Log.d(TAG, "onSubscribe");
                      mSubscription = s;
                      s.request(10);  //request 10
                  }

                  @Override
                  public void onNext(Integer integer) {
                      Log.d(TAG, "onNext: " + integer);
                  }

                  @Override
                  public void onError(Throwable t) {
                      Log.w(TAG, "onError: ", t);
                  }

                  @Override
                  public void onComplete() {
                      Log.d(TAG, "onComplete");
                  }
              });
  }

代码很简单,来看看运行结果:

  D/TAG: onSubscribe
  D/TAG: before emit, requested = 10
  D/TAG: emit 1
  D/TAG: onNext: 1
  D/TAG: after emit 1, requested = 9
  D/TAG: emit 2
  D/TAG: onNext: 2
  D/TAG: after emit 2, requested = 8
  D/TAG: emit 3
  D/TAG: onNext: 3
  D/TAG: after emit 3, requested = 7
  D/TAG: emit complete
  D/TAG: onComplete
  D/TAG: after emit complete, requested = 7

大家应该能看出端倪了吧,下游调用 request(n) 告诉上游它的处理能力,上游每发送一个 next 事件之后,requested就 减一,注意是next事件,complete和error事件不会消耗requested,当减到0时,则代表下游没有处理能力了,这个时候你如果继续发送事件,会发生什么后果呢?当然是MissingBackpressureException啦,试一试:

  public static void demo2() {
      Flowable.create(new FlowableOnSubscribe<Integer>() {
                  @Override
                  public void subscribe(final FlowableEmitter<Integer> emitter) throws Exception {
                      Log.d(TAG, "before emit, requested = " + emitter.requested());

                      Log.d(TAG, "emit 1");
                      emitter.onNext(1);
                      Log.d(TAG, "after emit 1, requested = " + emitter.requested());

                      Log.d(TAG, "emit 2");
                      emitter.onNext(2);
                      Log.d(TAG, "after emit 2, requested = " + emitter.requested());

                      Log.d(TAG, "emit 3");
                      emitter.onNext(3);
                      Log.d(TAG, "after emit 3, requested = " + emitter.requested());

                      Log.d(TAG, "emit complete");
                      emitter.onComplete();

                      Log.d(TAG, "after emit complete, requested = " + emitter.requested());
                  }
              }, BackpressureStrategy.ERROR)
              .subscribe(new Subscriber<Integer>() {

                  @Override
                  public void onSubscribe(Subscription s) {
                      Log.d(TAG, "onSubscribe");
                      mSubscription = s;
                      s.request(2);   //request 2
                  }

                  @Override
                  public void onNext(Integer integer) {
                      Log.d(TAG, "onNext: " + integer);
                  }

                  @Override
                  public void onError(Throwable t) {
                      Log.w(TAG, "onError: ", t);
                  }

                  @Override
                  public void onComplete() {
                      Log.d(TAG, "onComplete");
                  }
              });
  }

还是这个例子,只不过这次只 request(2), 看看运行结果:

  D/TAG: onSubscribe
  D/TAG: before emit, requested = 2
  D/TAG: emit 1
  D/TAG: onNext: 1
  D/TAG: after emit 1, requested = 1
  D/TAG: emit 2
  D/TAG: onNext: 2
  D/TAG: after emit 2, requested = 0
  D/TAG: emit 3
  W/TAG: onError: io.reactivex.exceptions.MissingBackpressureException: create: could not emit value due to lack of requests
                  at io.reactivex.internal.operators.flowable.FlowableCreate$ErrorAsyncEmitter.onOverflow(FlowableCreate.java:411)
                  at io.reactivex.internal.operators.flowable.FlowableCreate$NoOverflowBaseAsyncEmitter.onNext(FlowableCreate.java:377)
                  at zlc.season.rxjava2demo.demo.ChapterNine$4.subscribe(ChapterNine.java:80)
                  at io.reactivex.internal.operators.flowable.FlowableCreate.subscribeActual(FlowableCreate.java:72)
                  at io.reactivex.Flowable.subscribe(Flowable.java:12218)
                  at zlc.season.rxjava2demo.demo.ChapterNine.demo2(ChapterNine.java:89)
                  at zlc.season.rxjava2demo.MainActivity$2.onClick(MainActivity.java:36)
                  at android.view.View.performClick(View.java:4780)
                  at android.view.View$PerformClick.run(View.java:19866)
                  at android.os.Handler.handleCallback(Handler.java:739)
                  at android.os.Handler.dispatchMessage(Handler.java:95)
                  at android.os.Looper.loop(Looper.java:135)
                  at android.app.ActivityThread.main(ActivityThread.java:5254)
                  at java.lang.reflect.Method.invoke(Native Method)
                  at java.lang.reflect.Method.invoke(Method.java:372)
                  at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:903)
                  at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:698)
  D/TAG: after emit 3, requested = 0
  D/TAG: emit complete
  D/TAG: after emit complete, requested = 0

到目前为止我们一直在说同步的订阅,现在同步说完了,我们先用一张图来总结一下同步的情况:

同步request
同步request

这张图的意思就是当上下游在同一个线程中的时候,在下游调用 request(n) 就会直接改变上游中的requested的值,多次调用便会叠加这个值,而上游每发送一个事件之后便会去减少这个值,当这个值减少至0的时候,继续发送事件便会抛异常了。
我们再来说说异步的情况,异步和同步会有区别吗?会有什么区别呢?带着这个疑问我们继续来探究。
同样的先来看一个异步基本的例子:

  public static void demo3() {
      Flowable.create(new FlowableOnSubscribe<Integer>() {
                  @Override
                  public void subscribe(FlowableEmitter<Integer> emitter) throws Exception {
                      Log.d(TAG, "current requested: " + emitter.requested());
                  }
              }, BackpressureStrategy.ERROR)
              .subscribeOn(Schedulers.io())
              .observeOn(AndroidSchedulers.mainThread())
              .subscribe(new Subscriber<Integer>() {

                  @Override
                  public void onSubscribe(Subscription s) {
                      Log.d(TAG, "onSubscribe");
                      mSubscription = s;
                  }

                  @Override
                  public void onNext(Integer integer) {
                      Log.d(TAG, "onNext: " + integer);
                  }

                  @Override
                  public void onError(Throwable t) {
                      Log.w(TAG, "onError: ", t);
                  }

                  @Override
                  public void onComplete() {
                      Log.d(TAG, "onComplete");
                  }
              });
  }

这次是异步的情况,上游啥也不做,下游也啥也不做,来看看运行结果:

  D/TAG: onSubscribe
  D/TAG: current requested: 128

哈哈,又是128,看了我前几篇文章的朋友肯定很熟悉这个数字啊!这个数字为什么和我们之前所说的默认的水缸大小一样啊,莫非?
带着这个疑问我们继续来研究一下:

  public static void demo3() {
      Flowable.create(new FlowableOnSubscribe<Integer>() {
                  @Override
                  public void subscribe(FlowableEmitter<Integer> emitter) throws Exception {
                      Log.d(TAG, "current requested: " + emitter.requested());
                  }
              }, BackpressureStrategy.ERROR)
              .subscribeOn(Schedulers.io())
              .observeOn(AndroidSchedulers.mainThread())
              .subscribe(new Subscriber<Integer>() {

                  @Override
                  public void onSubscribe(Subscription s) {
                      Log.d(TAG, "onSubscribe");
                      mSubscription = s;
                      s.request(1000); //我要打1000个!!
                  }

                  @Override
                  public void onNext(Integer integer) {
                      Log.d(TAG, "onNext: " + integer);
                  }

                  @Override
                  public void onError(Throwable t) {
                      Log.w(TAG, "onError: ", t);
                  }

                  @Override
                  public void onComplete() {
                      Log.d(TAG, "onComplete");
                  }
              });
  }

这次我们在下游调用了 request(1000) 告诉上游我要打1000个,按照之前我们说的,这次的运行结果应该是1000,来看看运行结果:

  D/TAG: onSubscribe
  D/TAG: current requested: 128

卧槽,你确定你没贴错代码?
是的,真相就是这样,就是128,蜜汁128。。。
为了答疑解惑,我就直接上图了:

异步request
异步request

可以看到,当上下游工作在不同的线程里时,每一个线程里都有一个requested,而我们调用 request(1000) 时,实际上改变的是下游主线程中的requested,而上游中的requested的值是由RxJava内部调用request(n)去设置的,这个调用会在合适的时候自动触发。
现在我们就能理解为什么没有调用request,上游中的值是128了,因为下游在一开始就在内部调用了 request(128) 去设置了上游中的值,因此即使下游没有调用request(),上游也能发送128个事件,这也可以解释之前我们为什么说Flowable中默认的水缸大小是128,其实就是这里设置的。
刚才同步的时候我们说了,上游每发送一个事件,requested的值便会减一,对于异步来说同样如此,那有人肯定有疑问了,一开始上游的requested的值是128,那这128个事件发送完了不就不能继续发送了吗?
刚刚说了,设置上游requested的值的这个内部调用会在合适的时候自动触发,那到底什么时候是合适的时候呢?是发完128个事件才去调用吗?还是发送了一半才去调用呢?
带着这个疑问我们来看下一段代码:

  public static void request() {
      mSubscription.request(96); //请求96个事件
  }

  public static void demo4() {
      Flowable.create(new FlowableOnSubscribe<Integer>() {
                  @Override
                  public void subscribe(FlowableEmitter<Integer> emitter) throws Exception {
                      Log.d(TAG, "First requested = " + emitter.requested());
                      boolean flag;
                      for (int i = 0; ; i++) {
                          flag = false;
                          while (emitter.requested() == 0) {
                              if (!flag) {
                                  Log.d(TAG, "Oh no! I can't emit value!");
                                  flag = true;
                              }
                          }
                          emitter.onNext(i);
                          Log.d(TAG, "emit " + i + " , requested = " + emitter.requested());
                      }
                  }
              }, BackpressureStrategy.ERROR)
              .subscribeOn(Schedulers.io())
              .observeOn(AndroidSchedulers.mainThread())
              .subscribe(new Subscriber<Integer>() {

                  @Override
                  public void onSubscribe(Subscription s) {
                      Log.d(TAG, "onSubscribe");
                      mSubscription = s;
                  }

                  @Override
                  public void onNext(Integer integer) {
                      Log.d(TAG, "onNext: " + integer);
                  }

                  @Override
                  public void onError(Throwable t) {
                      Log.w(TAG, "onError: ", t);
                  }

                  @Override
                  public void onComplete() {
                      Log.d(TAG, "onComplete");
                  }
              });
  }

这次的上游稍微复杂了一点点,首先仍然是个无限循环发事件,但是是有条件的,只有当上游的requested != 0的时候才会发事件,然后我们调用 request(96) 去消费96个事件(为什么是96而不是其他的数字先不要管),来看看运行结果吧:

  D/TAG: onSubscribe
  D/TAG: First requested = 128
  D/TAG: emit 0 , requested = 127
  D/TAG: emit 1 , requested = 126
  D/TAG: emit 2 , requested = 125
    ...
  D/TAG: emit 124 , requested = 3
  D/TAG: emit 125 , requested = 2
  D/TAG: emit 126 , requested = 1
  D/TAG: emit 127 , requested = 0
  D/TAG: Oh no! I can't emit value!

首先运行之后上游便会发送完128个事件,之后便不做任何事情,从打印的结果中我们也可以看出这一点。
然后我们调用request(96),这会让下游去消费96个事件,来看看运行结果吧:

  D/TAG: onNext: 0
  D/TAG: onNext: 1
    ...
  D/TAG: onNext: 92
  D/TAG: onNext: 93
  D/TAG: onNext: 94
  D/TAG: onNext: 95
  D/TAG: emit 128 , requested = 95
  D/TAG: emit 129 , requested = 94
  D/TAG: emit 130 , requested = 93
  D/TAG: emit 131 , requested = 92
    ...
  D/TAG: emit 219 , requested = 4
  D/TAG: emit 220 , requested = 3
  D/TAG: emit 221 , requested = 2
  D/TAG: emit 222 , requested = 1
  D/TAG: emit 223 , requested = 0
  D/TAG: Oh no! I can't emit value!

可以看到,当下游消费掉第96个事件之后,上游又开始发事件了,而且可以看到当前上游的requested的值是96(打印出来的95是已经发送了一个事件减一之后的值),最终发出了第223个事件之后又进入了等待区,而223-127 正好等于 96
这是不是说明当下游每消费96个事件便会自动触发内部的request()去设置上游的requested的值啊!没错,就是这样,而这个新的值就是96。
朋友们可以手动试试请求95个事件,上游是不会继续发送事件的。
至于这个96是怎么得出来的(肯定不是我猜的蒙的啊),感兴趣的朋友可以自行阅读源码寻找答案,对于初学者而言应该没什么必要,管它内部怎么实现的呢对吧。
好了今天的教程就到这里了!通过本节的学习,大家应该知道如何正确的去实现一个完整的响应式拉取了,在某一些场景下,可以在发送事件前先判断当前的requested的值是否大于0,若等于0则说明下游处理不过来了,则需要等待,例如下面这个例子。

实践

这个例子是读取一个文本文件,需要一行一行读取,然后处理并输出,如果文本文件很大的时候,比如几十M的时候,全部先读入内存肯定不是明智的做法,因此我们可以一边读取一边处理,实现的代码如下:

  public static void main(String[] args) {
      practice1();
      try {
          Thread.sleep(10000000);
      } catch (InterruptedException e) {
          e.printStackTrace();
      }
  }

  public static void practice1() {
      Flowable.create(new FlowableOnSubscribe<String>() {
                  @Override
                  public void subscribe(FlowableEmitter<String> emitter) throws Exception {
                      try {
                          FileReader reader = new FileReader("test.txt");
                          BufferedReader br = new BufferedReader(reader);

                          String str;

                          while ((str = br.readLine()) != null && !emitter.isCancelled()) {
                              while (emitter.requested() == 0) {
                                  if (emitter.isCancelled()) {
                                      break;
                                  }
                              }
                              emitter.onNext(str);
                          }

                          br.close();
                          reader.close();

                          emitter.onComplete();
                      } catch (Exception e) {
                          emitter.onError(e);
                      }
                  }
              }, BackpressureStrategy.ERROR)
              .subscribeOn(Schedulers.io())
              .observeOn(Schedulers.newThread())
              .subscribe(new Subscriber<String>() {

                  @Override
                  public void onSubscribe(Subscription s) {
                      mSubscription = s;
                      s.request(1);
                  }

                  @Override
                  public void onNext(String string) {
                      System.out.println(string);
                      try {
                          Thread.sleep(2000);
                          mSubscription.request(1);
                      } catch (InterruptedException e) {
                          e.printStackTrace();
                      }
                  }

                  @Override
                  public void onError(Throwable t) {
                      System.out.println(t);
                  }

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

运行的结果便是:

poetry
poetry

好了,本教程到此结束。再次感谢原作者!!!

相关资源

  1. RxJava

  2. 简书 RxJava2.x 专题

  3. 给 Android 开发者的 RxJava 详解

  4. RxJava 2.0有什么不同(译)

联系

我是 xiaobailong24,您可以通过以下平台找到我: