Question

例如，你可以这样做：

Future(/* A */).flatMap(_ => Future(/* B */).flatMap(_ => Future(/* C */)))

这里B取决于A来完成，是否有一种干净的方式来组成期货，以便C依赖A和B来完成，A和B可以并行运行？

Answer 1

我认为您所寻找的是Future.sequence方法，可以将Future的序列缩减为单个Future。这是一个简单的例子：

def createFuture(name: String, sleep: Int): Future[(String, Int)] = {
  Future({
    println(s"Starting $name with sleep $sleep")
    Thread.sleep(sleep)
    println(s"After $name")
    (name, sleep)
  })
}

val rnd = new Random()
val fa = createFuture("A", rnd.nextInt(1000) + 500)
val fb = createFuture("B", rnd.nextInt(1000) + 500)
val ff = Future.sequence(List(fa, fb)).flatMap(l => createFuture("C" + l.map(_._2).sum, 100))
Await.result(ff, Duration.Inf)

其中一个运行的输出是：

用睡眠启动B 1287
  睡眠起始A 550   A
之后   在B
之后   睡眠时启动C1837 100   C1837之后

如果您还希望“快速失败”，您可以考虑How to wait for several Futures

中更复杂的答案

Answer 2

for yield是干净利落的方式，它等于flatMap，如：

val futureA = Future {
  // do something
}
val futureB = Future {
  // do something
}
for {
_ <- futureA
_ <- futureB
} yield Future {
  /* C */
}

futureA之前的初始futureB和for comprehensive，它们将并行运行。

Answer 3

Future(A).zipWith(Future(B))((_,_) => C)

你怎么能在Scala中组成依赖的未来，以便除了一个以外的所有并行运行？

3 个答案: