Scala 如何在.mapParallelUnordered中处理错误并保持可观察状态

我使用的是

Monix 3

，有一种这样的代码：

  Observable.fromIterable(Seq(1, 2, 3, 4, 5, 6, 7, 8, 9))
    .flatMap(i =>
      if (i % 2 == 0) {   // Bad i
        Observable.empty
      } else
        Observable.pure(i)
    )
    .foreachL(i => print(s"Good i: $i"))   /*Output: Good i: 1
                                                     Good i: 3
                                                     Good i: 5
                                                     Good i: 7
                                                     Good i: 9*/

这段代码运行良好，但我有很多长时间的IO操作，因此决定使用

.mappallelunordered

：

  Observable.fromIterable(Seq(1, 2, 3, 4, 5, 6, 7, 8, 9))
    .mapParallelOrdered(3)(i =>
      if (i % 2 == 0) {
        Task.raiseError(new Exception(s"Bad i: $i"))
      } else
        Task.pure(i)
    )
    .foreachL(i => print(s"Good i: $i"))    /*Output: Good i: 1*/

我试图得到与第一个示例相同的结果，但是在并行处理中。问题是

Task。raiseError

杀死一个完整的可观察对象，因此它在

i=2

上停止

如何处理错误并保持可观察状态？

您可以尝试以下方法：

Observable
  .fromIterable(Seq(1, 2, 3, 4, 5, 6, 7, 8, 9))
  .mapParallelOrdered(3)(
    i =>
      if (i % 2 == 0) {
        Task.pure(Left("Error"))
      } else
        Task.pure(Right(i))
  )
  .collect {
    case Right(i) => i
  }
  .foreachL(i => print(s"Good i: $i"))

---

很难说出你想要实现什么。也许下次再多解释一下你的情况。@MarkusAppel更新了问题：我正试图得到与第一个例子相同的结果，但是在并行处理中。问题是

Task。raiseError

杀死了一个完整的可观察对象，因此它在

i=2

上停止。我需要理解为什么在示例中使用

Task.raiseError

。它代表什么？您想“过滤”掉任何未成功的I/O操作吗？@MarkusAppel-yes。某些操作可能会失败。在第一个示例中，我可以使用

Observable.empty

进行恢复，这将跳过以下所有操作，例如

foreachL…

。但第一个例子并不是并行运行的。第二个并行运行，但我不知道如何跳过失败的操作。@Oleg我在你的问题中添加了

scala

标记。语言标记是最容易观察到的，因此添加它可能会让您的问题得到更多的关注。