Scala 等待另一个将来结束以返回函数

假设我有一个函数

func1

，它需要返回一个带有两个整数的

Future

。两个值中的每一个都由独立的期货返回，如下所示：

def f1 = Future { 1 }
def f2 = Future { 2 }

def func1 : Future[(Int,Int)] = {

    val future1 = f1
    future1.map { result1 =>
       result1 * 10
    }

    val future2 = f2
    future2.map { result2 =>
       result2 * 20
    }

} 

---

我需要

future1

等待

future2

结束（反之亦然），以

（Int，Int）

的形式返回两个结果。如何才能做到这一点？

对于，理解是最好的选择：

scala> import scala.concurrent.Future
import scala.concurrent.Future

scala> import concurrent.ExecutionContext.Implicits.global
import concurrent.ExecutionContext.Implicits.global

scala> def f1 = Future{1}
f1: scala.concurrent.Future[Int]

scala> def f2 = Future{2}
f2: scala.concurrent.Future[Int]

scala> for {result1 <- f1; result2 <- f2} yield (result1 * 10, result2 * 20)
res0: scala.concurrent.Future[(Int, Int)] = scala.concurrent.impl.Promise$DefaultPromise@71f67a79

scala>导入scala.concurrent.Future
导入scala.concurrent.Future
scala>导入concurrent.ExecutionContext.Implicits.global
导入concurrent.ExecutionContext.Implicits.global
scala>def f1=Future{1}
f1:scala.concurrent.Future[Int]
scala>def f2=未来{2}
f2:scala.concurrent.Future[Int]
scala>for{result1这正是期货上的
zip
方法所做的：

val futurePair: Future[(Int, Int)] = future1.zip(future2)

请注意，如果您以前没有实例化您的期货（例如，如果
future1
和
future2
是
def
s，而不是
val
s），这将并行运行两个计算，而一个用于理解（或
flatMap
）将等待第一个成功，然后再开始第二个。
您可以使用以下方法来理解已经开始的期货：

val f1: Future[Int] = ???
val f2: Future[Int] = ???
val f3: Future[Int] = ???

val futureInts: Future[(Int, Int, Int)] = for {
  result1 <- f1
  result2 <- f2
  result3 <- f3
} yield (result1, result2, result3)

输出：

starting f1 // These first 
starting f3 // threes statements
starting f2 // happen right away.

(1,2,2)     // Then this prints a three seconds later

在您的情况下，您可以这样做：

def func1 : Future[(Int,Int)] = {

  // Start futures
  val future1 = f1.map(_ * 10)
  val future2 = f2.map(_ * 20)

  // Wait for both futures, and return a tuple
  for {
    result1 <- future1
    result2 <- future2
  } yield (result1, result2)

}

def func1:Future[（Int，Int）]={
//开创未来
val future1=f1.地图（*10）
val future2=f2.地图（*20）
//等待两个未来，然后返回一个元组
为了{
结果1按顺序运行f1和f2。另一个答案更好。如果有3个或4个未来，会发生什么？可能有一个元组4吗？还是会是嵌套元组？它将是嵌套元组。但您可以始终使用
map
为它们提供所需的形式。如果您有
列表[Future[Int]]
，您甚至可以使用静态方法
Future.sequence
等待它们全部进入
Future[List[Int]]
。要解释我使用
map
的意思，您可以执行
future1 zip future2 zip future3 map{case（（a，b），c）=>（a，b，c）}
def func1 : Future[(Int,Int)] = {

  // Start futures
  val future1 = f1.map(_ * 10)
  val future2 = f2.map(_ * 20)

  // Wait for both futures, and return a tuple
  for {
    result1 <- future1
    result2 <- future2
  } yield (result1, result2)

}