同步2个或更多Futures的计算

Question

我发现我无法弄清楚如何同步2和更多的计算Futures:

val fs = List(1, 2, 3) map { x => Future { /* some computation depending on x... */ } }
fs(0) onComplete {
  case Success(x) => 
    fs(1) onComplete { 
      case Success(x) => 
        fs(2) onComplete ....
}

这看起来不合理.

我想从中得到所有的价值fs.我该怎么做呢？

Answer 1

使用 Future.traverse

val inList = List(1, 2, 3)
val fs = Future.traverse(inList) { x =>
  Future {
    /* some computation depending on x... */
  }
}

fs onSuccess { case outList => 
  ...
}

如果任何元素失败,这将失败.

如果您想要所有结果,无论失败或成功,那么最好的方法是将recover它们包装在以下实例中Try:

def asyncFunc(i: Int): Future[String] = ...

val inList = List(1, 2, 3)
val rawResults = inList.map(asyncFunc)
val recoveredResults = rawResults.map(Success(_)).recover(case x => Failure(x))

val completedResults = Future.sequence(recoveredResults)

completedResults onSuccess { case outList =>
  outList map {
    case Success(s) => ...
    case Failure(t) => ...
  }
}

提示:如果你做了很多这样的事情,通常更容易确保你的所有异步方法成功完成Future[Try[T]],而不是嵌入任何错误Future

像这样的东西:

def slowFunc(i: Int): String = ...
def asyncFunc(i: Int): Future[Try[String]] = Future { Try { slowFunc(i) } }

val inList = List(1, 2, 3)
val results = Future.traverse(inList)(asyncFunc)

results onSuccess { case outList =>
  outList map {
    case Success(s) => ...
    case Failure(t) => ...
  }
}

Answer 2

您可以使用Future.sequence将您的转换List[Future]为Future[List]：

val fs = List(1, 2, 3) map { x => Future(x * x) }
val f = Future.sequence(fs)
f.onComplete(println(_))

会打印 Success(List(1, 4, 9))