Question

我将两个observable连接起来，首先显示缓存中的数据，然后开始从网络加载数据并显示更新的数据。

Observable.concat(
    getContentFromCache.subscribeOn(dbScheduler),
    getContentFromNetwork.subscibeOn(networkScheduler)
).observeOn(AndroidSchedulers.mainThread())
 .subscribe(subscriber);

如果没有网络连接，则在调用OnSubscribe后第二个observable会立即失败。

如果第二个observable立即失败，第一个observable的数据将丢失。订阅者永远不会调用onNext方法。

我认为，这可能是由于OperatorConcat.ConcatSubscriber中的以下代码所致

    @Override
    public void onNext(Observable<? extends T> t) {
        queue.add(nl.next(t));
        if (WIP_UPDATER.getAndIncrement(this) == 0) {
            subscribeNext();
        }
    }

    @Override
    public void onError(Throwable e) {
        child.onError(e);
        unsubscribe();
    }

看起来收到错误后它会取消订阅，并且所有挂起的onNext都会丢失。

解决问题的最佳方法是什么？

更新

看起来我找到了解决方案，而不是为连接的observable设置observOn，我为每个observable设置了observOn。

Observable.concat(
    getContentFromCache.subscribeOn(dbScheduler).observeOn(AndroidSchedulers.mainThread()),
    getContentFromNetwork.subscibeOn(networkScheduler).observeOn(AndroidSchedulers.mainThread())
)
 .subscribe(subscriber);

Answer 1

observeOn的默认行为是onError个事件可以跳到队列前面，这是来自文档的引用：

请注意，onError通知会在onNext次通知之前删除如果Scheduler真正异步，则在发射线程上。

这是一个很小的测试来说明事情：

Scheduler newThreadScheduler = Schedulers.newThread();

Observable<Integer> stream = Observable.create(integerEmitter -> {
    integerEmitter.onNext(1);
    integerEmitter.onNext(2);
    integerEmitter.onNext(3);
    integerEmitter.onNext(4);
    integerEmitter.onNext(5);
    integerEmitter.onError(new RuntimeException());
}, Emitter.BackpressureMode.NONE);

TestSubscriber<Integer> subscriber = new TestSubscriber<>();
stream.subscribeOn(Schedulers.computation())
        .observeOn(newThreadScheduler).subscribe(subscriber);

subscriber.awaitTerminalEvent();

subscriber.assertValues(1, 2, 3, 4, 5);
subscriber.assertError(RuntimeException.class);

通常消费者会期望以下顺序：1＆gt; 2＆gt; 3> 4> 5> Error。但仅使用observeOn可能会导致错误，测试将失败。

此行为很久以前在https://github.com/ReactiveX/RxJava/issues/1680实施，检查为什么这样做的动机。为避免此类行为，可以使用带有observeOn参数的重载delayError：

表示onError通知是否可能不会在onNext之前切断调度边界另一侧的通知。如果true以onError结尾的序列将按照收到的顺序重播来自上游

这是您通常所期望的，因此将observeOn(newThreadScheduler)更改为observeOn(newThreadScheduler, true)将会解决问题。

接下来是@Neil的问题：为什么@Rostyslav提出的解决方案有效？它正在工作，因为最终序列没有线程切换。

在提出的解决方案中，最终序列是由同一线程上的两个序列组成的：第一个序列是来自缓存的数据，第二个序列只是来自网络的错误。它们在同一个线程上一起制作，并且在没有线程切换之后 - 订阅者在AndroidSchedulers.mainThread()上观察。如果您尝试将最终Scheduler更改为其他，则会再次失败。

Answer 2

This is the small Example for concat both Observable

// First Observable //   
 private Observable<Book> getAutobiography()
        {
            String [] booknames= new String[]{"book1","book2"};
            final ArrayList<Book> arrayList = new ArrayList<>();
            for(String name:booknames){
                Book book = new Book();
                book.setBooktype("Autobiograph");
                book.setBookname(name);
                arrayList.add(book);
            }

            return Observable.create(new ObservableOnSubscribe<Book>() {
                @Override
                public void subscribe(ObservableEmitter<Book> emitter) throws Exception {

                    for(Book book:arrayList)
                    {
                        emitter.onNext(book);

                    }
                    if (!emitter.isDisposed()) {
                        emitter.onComplete();
                    }
                }
            }).subscribeOn(Schedulers.io());
        }

// Second Observable 



    private Observable<Book> getProgrammingBooks()
        {
            String [] booknames= new String[]{"book3","book4"};
            final ArrayList<Book> arrayList = new ArrayList<>();
            for(String name:booknames){
                Book book = new Book();
                book.setBooktype("Programming");
                book.setBookname(name);
                arrayList.add(book);
            }

            return Observable.create(new ObservableOnSubscribe<Book>() {
                @Override
                public void subscribe(ObservableEmitter<Book> emitter) throws Exception {

                    for(Book book:arrayList)
                    {
                        emitter.onNext(book);

                    }
                    if (!emitter.isDisposed()) {
                        emitter.onComplete();
                    }
                }
            }).subscribeOn(Schedulers.io());
        }

// Concat them 

    Observable.concat(getProgrammingBooks(),getAutobiography()).observeOn(AndroidSchedulers.mainThread()).subscribe(new Observer<Book>() {
        @Override
        public void onSubscribe(Disposable d) {

        }

        @Override
        public void onNext(Book book) {


            Log.d("bookname",""+book.getBookname());
            Log.d("booktype",""+book.getBooktype());
        }

        @Override
        public void onError(Throwable e) {

        }

        @Override
        public void onComplete() {

        }
    });
// it print both values //

如果第二个立即失败，ReactiveX concat不会从第一个observable产生onNext

2 个答案: