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不同，{{3}}处理已知数量的未来。

Answer 1

使用Future.sequence将期货清单[T]转换为单个期货清单[T]。

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

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

等待未知数量的期货

1 个答案: