RxJava - 小心 observeOn 的陷阱

在 Android 中使用 RxJava 经常会用到 observeOn 这个操作符来完成线程的切换，比如网络请求之后切换到“主线程”，通常会这么写：

  Observable.observeOn(AndroidSchedulers.mainThread())

然而我遇到一个奇怪的问题，onNext 有时候会丢失，先描述一下场景。我用 Retrofit + RxJava 来进行网络请求，我可以直接拿到一个 Observable，就像下面这样：

// 定义 Retrofit 接口
public interface FeedApi {    
  @GET("feeds")    
  Observable> feeds();
}
// 省略部分代码
RestApi restApi = retrofit.create(RestApi.class);

Observable> observable = restApi.feeds()
      .subscribeOn(Schedulers.io())       
      .observeOn(AndroidSchedulers.mainThread());

observable.subscribe(...);

目前来看一切正常，我为了更好的用户体验，加入了缓存，当网络有问题的时候，会显示缓存数据，用户不会看到一个空白的页面。缓存的方式多种多样，比如 Realm，同样支持 RxJava，我依然可以拿到一个 Observable，然后我使用 concat 把来自缓存的 Observable 和来自网络的 Observable 合并为一个 Observable 对外提供，就像下面这样：

Observable> fromNetwork = ...
Observable> fromCache = ...

Observable> observable = Observable.concat(fromCache, fromNetwork)
      .subscribeOn(Schedulers.io())       
      .observeOn(AndroidSchedulers.mainThread());

observable.subscribe(...);

合并之后的 Observable 继续使用 subscribeOn 和 observeOn 来完成线程的切换。恩，看起来很完美，我想象中运行效果是这样的：

假设已经存在缓存的情况下
网络正常的时候，fromCache 从缓存拿到数据发送给 Subscriber，显示到页面上，然后 fromNetwork 从服务器拿到最新的数据，继续发送给 Subscriber，刷新页面为最新的数据，Subscribe 会经历 onNext() -> onNext() -> onCompleted()。
网络异常的情况，fromCache 从缓存拿到数据发送给 Subscriber，显示到页面上，然后 fromNetwork 发生异常，Subscriber 收到 Error，可以提示用户网络异常，但是页面上会显示缓存的数据，用户不会看到空白页面，Subscriber 会经历 onNext() -> onError()。

我运行之后，在网络正常的情况下，能显示数据，当我把网络关闭的时候，依然能显示数据，数据是从缓存加载的，还不错，和我想象的一样。但是当我反复多次打开页面的时候，发现一个奇怪的现象，页面有时候会显示空白，有时候会显示缓数据，但是都会提示网络异常的信息，从 Subscriber 的角度讲，就是 Subscriber 有时候会 onNext() -> onError()，有时候只会 onError()，缓存数据的那次 onNext() 丢失了！

为了搞清楚这个问题，我做了这样的测试，在 subscribe 之前各个环节加上 doOnNext，观察会不会执行。

observable        
  .doOnNext(s -> log("1 doOnNext: " + s))                    
  .subscribeOn(Schedulers.io())  
  .doOnNext(s -> log("2 doOnNext: " + s))            
  .observeOn(AndroidSchedulers.mainThread())
  .doOnNext(s -> log("3 doOnNext: " + s))
  .subscribe(...);

// 输出结果
1 doOnNext: test
2 doOnNext: test

第三个居然没有打印，说明 observeOn 之后的 onNext() 没有执行，确定了问题范围之后，我尝试从 observeOn 的源码寻找线索。我发现 observeOn 有几个重载的方法，其中有一个参数叫 delayError，看名字是“延迟错误”。

public final Observable observeOn(Scheduler scheduler, boolean delayError);

注释对这个参数的描述是：

indicates if the onError notification may not cut ahead of onNext notification on the other side of the scheduling boundary. If true a sequence ending in onError will be replayed in the same order as was received from upstream

大概说 delayError 决定了 onError 会不会切断 onNext 通知，貌似和我的问题有些关系，为了弄清楚具体情况，还是看源码。
observeOn 基于 lift 操作符，lift 需要一个 Operator，Operator 可以将 下游 Subscriber 进行“代理”，返回一个 “代理” Subscriber 对象，“代理”对象可以收到 onNext、onError、onCompleted，然后可以进行一些处理，再选择性的发送给 下游 Subscriber。

public final Observable observeOn(Scheduler scheduler, boolean delayError, int bufferSize) {    
  if (this instanceof ScalarSynchronousObservable) {
    return ((ScalarSynchronousObservable)this).scalarScheduleOn(scheduler);    
  }    
  // OperatorObserveOn 是关键
  return lift(new OperatorObserveOn(scheduler, delayError, bufferSize));
}

我们继续看 OperatorObserveOn。

public final class OperatorObserveOn implements Operator {

    ...

    @Override
    public Subscriber call(Subscriber child) {
        // 创建一个 Subscriber “代理”
        ObserveOnSubscriber parent = new ObserveOnSubscriber(scheduler, child, delayError, bufferSize);
        parent.init();
        return parent;
    }

    // Subscriber 的代理，它会代理 下游的 Subscriber 收到事件
    // 然后在 Scheduler 的线程中再转发给 下游的 Subscriber，就完成了线程的切换
    static final class ObserveOnSubscriber extends Subscriber implements Action0 {

        @Override
        public void onNext(final T t) {
            // 代理对象先收到 onNext
            if (isUnsubscribed() || finished) {
                return;
            }
            // 把收到的数据放到一个队列中
            if (!queue.offer(NotificationLite.next(t))) {
                onError(new MissingBackpressureException());
                return;
            }
            // 通知 Scheduler，Scheduler 会回调 call 方法
            schedule();
        }

        @Override
        public void onCompleted() {
            if (isUnsubscribed() || finished) {
                return;
            }
            // 标记 流 已经结束
            finished = true;
            // 通知 Scheduler，Scheduler 会回调 call 方法
            schedule();
        }

        @Override
        public void onError(final Throwable e) {
            if (isUnsubscribed() || finished) {
                RxJavaHooks.onError(e);
                return;
            }
            // 保存 error
            error = e;
            // 标记 流 已经结束
            finished = true;
            // 通知 Scheduler，Scheduler 会回调 call 方法
            schedule();
        }

        protected void schedule() {
            if (counter.getAndIncrement() == 0) {
                // 把 this 当做一个 callback，Scheduler 会调用 call 方法。
                recursiveScheduler.schedule(this);
            }
        }

        // only execute this from schedule()
        @Override
        public void call() {
            // 从 Scheduler 中调用，此时已经在 Scheduler 的线程中，比如 Android 的主线程中
            long missed = 1L;
            long currentEmission = emitted;

            final Queue