Question

我使用combineLatest连接两个流和两种类型的任务。处理两种类型的任务应该是交错的。是否可以确定哪个流发出最后一对值？我使用带有时间戳的解决方案，但它不正确。每个主题都包含默认值。

List<Flowable<? extends Timed<? extends Task>>> sources = new ArrayList<>();

Flowable<Timed<TaskModification>> modificationSource = mTaskModificationSubject
      .onBackpressureDrop()
      .observeOn(Schedulers.io(), false, 1)
      .timestamp();

Flowable<Timed<TaskSynchronization>> synchronizationSource = mTaskSynchronizationSubject
      .onBackpressureDrop()
      .observeOn(Schedulers.io(), false, 1)
      .flatMap(TaskSynchronizationWrapper::getSources)
      .timestamp();

sources.add(0, modificationSource);
sources.add(1, synchronizationSource);

return Flowable
  .combineLatest(sources, array -> {
    Timed<TaskModification> taskModification = (Timed<TaskModification>) array[0];
    Timed<TaskSynchronization> taskSynchronization = (Timed<TaskSynchronization>) array[1];
    return (taskModification.time() > taskSynchronization.time())
      ? taskModification.value()
      : taskSynchronization.value();
  }, 1)
  .observeOn(Schedulers.io(), false, 1)
  .flatMapSingle(
    Task::getSource
  )
  .ignoreElements();

Answer 1

当发出修改任务时，应该优先于同步任务。

如果不实现自定义运算符，您可以引入队列，合并信号，然后首先从优先级队列中选择项目：

Flowable<X> prioritySource = ...
Flowable<X> source = ...

Flowable<X> output = Flowable.defer(() -> {
    Queue<X> priorityQueue = new ConcurrentLinkedQueue<>();
    Queue<X> queue = new ConcurrentLinkedQueue<>();

    return Flowable.merge(
         prioritySource.map(v -> {
             priorityQueue.offer(v);
             return 1;
         }),
         source.map(v -> {
             queue.offer(v);
             return 1;
         })
    )
    .map(v -> {
        if (!priorityQueue.isEmpty()) {
            return priorityQueue.poll();
        }
        return queue.poll();
    });
});

Operator CombineLatest - 可以确定最后一个项目的流吗？

1 个答案: