Question

我正在使用delay的签名：

public final <U> Observable<T> delay(Func1<? super T,? extends Observable<U>> itemDelay)

javadoc

我使用Func1返回Observable作为一种“触发器”。我的目标是延迟项目，直到外部异步操作完成。一旦该操作完成，我想要发布所有已延迟的项目以及所有未来的项目按顺序。

以下是一些示例代码，展示了我正在尝试做的事情：

import java.util.concurrent.atomic.AtomicBoolean;

import io.reactivex.Observable;
import io.reactivex.ObservableTransformer;
import io.reactivex.functions.Consumer;
import io.reactivex.schedulers.Schedulers;
import io.reactivex.subjects.ReplaySubject;

public class Example {

    private ReplaySubject<Object> delayTrigger = ReplaySubject.create(); // (1)

    public void main() {
        System.out.println("============ MAIN ============");
        SourceThread sourceThread = new SourceThread();
        sourceThread.start();

        sourceThread.stream
                .compose(doOnFirst(integer -> startAsyncOperation())) // (2)
                .delay(integer -> delayTrigger) // (3)
                .subscribeOn(Schedulers.io())
                .observeOn(Schedulers.io())
                .subscribe((Integer integer)
                        -> System.out.println("onNext: " + integer));
    }

    private void startAsyncOperation() {
        System.out.println(">>>>>>> long async operation started");
        SomeOtherThread someOtherThread = new SomeOtherThread();
        someOtherThread.start();
    }

    private void onAsyncOperationComplete() {
        System.out.println("<<<<<<< long async operation completed");
        delayTrigger.onNext(new Object()); // (4)
    }

    /**
     * From https://stackoverflow.com/a/32366794
     */
    private <T> ObservableTransformer<T, T> doOnFirst(Consumer<? super T> consumer) {
        return observableTransformer -> Observable.defer(() -> {
            final AtomicBoolean first = new AtomicBoolean(true);
            return observableTransformer.doOnNext(t -> {
                if (first.compareAndSet(true, false)) {
                    consumer.accept(t);
                }
            });
        });
    }

    /**
     * Some thread to simulate a some time delayed source.
     * This is not really part of the problem,
     * we just need a time delayed source on another thread
     */
    private final class SourceThread extends Thread {
        private ReplaySubject<Integer> stream = ReplaySubject.create();

        @Override
        public void run() {
            super.run();
            for (int i = 0; i < 100; i++) {
                stream.onNext(i);
                System.out.println("Source emits item: " + i);
                try {
                    Thread.sleep(20);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    private final class SomeOtherThread extends Thread {
        @Override
        public void run() {
            super.run();
            try {
                Thread.sleep(1000);
                onAsyncOperationComplete();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

在（1）我创建一个ReplaySubject作为我的触发器，在（2）我开始异步操作，在（3）我延迟直到触发器发出一些东西;最后在（4）当异步操作完成时，我将一些东西放入触发流中。

这在大多数情况下都可以正常工作，除非异步操作完成，从delay返回的流不正常。

I/System.out: Source emits item: 46
I/System.out: Source emits item: 47
I/System.out: <<<<<<< long async operation completed
I/System.out: Source emits item: 48
I/System.out: onNext: 0
I/System.out: onNext: 48 <---- problem here!!!
I/System.out: onNext: 1
I/System.out: onNext: 2
I/System.out: onNext: 3

项目48在项目1 - 47之前从delay发出。项目49也将不按顺序发出。这将继续，直到发出项目1-47，然后流清理。但是有很多未订购的商品。有没有办法解决这个问题？我正确使用delay吗？这是延迟的错误吗？

作为参考，这只是一个样本。在我的“真实”问题中，一旦它们出现故障，我就无法对发出的物品进行重新排序（即它们没有很好的编号）。

Answer 1

delay运算符没有排序保证，因为项目＃1的内部源通常比项目＃2的另一个内部源更晚发出信号。任何异步信号都可能会抛弃排序，即使来自诸如已终止ReplaySubject的来源。

我假设您想要预取主要来源，但在外部信号之前不要让它通过，对吧？在这种情况下，您可以使用concatArrayEager，其中第一个源的完成触发了预取的第二个源的发射：

PublishSubject<Integer> delayer = PublishSubject.create();

Observable.concatArrayEager(
    delayer,
    sourceThread.stream
)

// somewhere async
delayer.onComplete();

RxJava2的延迟（rx.functions.Func1）不按顺序发出项目

1 个答案: