等待未知数量的期货

Question

在 Scala 2.10 中，编写一个返回一个未来的函数的正确方法是什么，该未来会在列表中的所有未来都完成时完成？

经过研究和实验，我在 Scala 工作表中开发了以下代码：

import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.duration._
import scala.concurrent._

object ws2 {

  def executeFutures(futures: Seq[Future[Unit]]): Future[Unit] = {

    def cascadeFutures(futureSeq: Seq[Future[Unit]], f: Future[Unit]): Future[Unit] = {
      futureSeq match {
        case h :: t => h.flatMap { u => cascadeFutures(t, f) }
        case nil => f
      }
    }

    cascadeFutures(futures, Future {})
  }                                               //> executeFutures: (futures: Seq[scala.concurrent.Future[Unit]])scala.concurren
                                                  //| t.Future[Unit]


  Await.ready(executeFutures(Seq(
    Future { println("Future1") },
    Future { println("Future2") },
    Future { println("Future3") }
  )) , 2.seconds)                                 //> Future1
                                                  //| Future2
                                                  //| Future3
                                                  //| res0: awaitable.type = scala.concurrent.impl.Promise$DefaultPromise@2dd063b3
                                                  //| 

}

我不确定这段代码是否正确，或者，即使它是正确的，也不确定是否有更好的方法。

如果期货是串行执行而不是并行执行，这不是问题。

这个问题不同于Wait for several Futures，后者处理已知数量的期货。

Answer 1

使用 Future.sequence 将 Futures[T] 列表转换为 List[T] 的单个 Future。

val listOfFutures:List[Future[T]] = ...
val futureOfList:Future[List[T]] = Future.sequence(listOfFutures)

这不仅适用于Lists，也适用于任何TraversableOnce，包括大部分（如果不是全部）scala.collections。