scala - 等待未知数量的 future

Question

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

经过研究和试验，我在 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
                                                  //| 

}

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

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

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

Answer 1

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

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

这不仅适用于 List s，但对于任何 TraversableOnce ，其中包括大部分(如果不是全部) scala.collections .