Scala 让一个未来等待另一个未来再去

我有问题。我需要一个未来来等待另一个未来在运行之前完成。我的编码如下：

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

object Test {

  def foo = Future {
    // take big time to finishing
    Thread.sleep(10000)
    println("Doned foo")
  }

  def bar = Future {
    // some small tasks
    println("Doned bar")
  }

  def main(args: Array[String]): Unit = {
    for {
      _ <- foo
    } yield {
      for {
        _ <- bar
      } yield()
    }
  }

}

导入scala.concurrent.ExecutionContext.Implicits.global
导入scala.concurrent.Future
对象测试{
def foo=未来{
//花很长时间来完成
线程。睡眠（10000）
println（“Doned foo”）
}
def bar=未来{
//一些小任务
println（“已完成的酒吧”）
}
def main（参数：数组[字符串]）：单位={
为了{
_对Scala中的未来进行了热切的评估，没有简单的方法可以让它们变得懒惰。一种方法是将未来的创建封装在函数中，你就是这样做的，所以你的问题与此无关

你的错误在于，你开始了你的未来，但是你没有等待它们，你的应用程序在它们的评估结束之前就完成了。你必须在
main
方法的末尾添加
wait.result

另一件不必要的事情是嵌套理解。理解中的每个调用都是按顺序进行的（它转换为
map
或
flatMap
），因此
bar
将等待
foo
完成

import scala.concurrent.{Await, Future}
import scala.concurrent.ExecutionContext.Implicits._
import scala.concurrent.duration._

def foo = Future {
    // take big time to finishing
    Thread.sleep(1000)
    println("Doned foo")
}

def bar = Future {
    // some small tasks
    Thread.sleep(1000)
    println("Doned bar")
}

def main(args: Array[String]): Unit = {
    val future = for {
      _ <- foo 
      _ <- bar //this future waits until foo is done
    } yield ()


    Await.result(future, 3000.millis)
}

很简单：

for {
  f1 <- foo1()
  f2 <- foo2(f1)
  f3 <- foo3(f2)
  _  <- Future{f1 + f2 + f3} //depends on foo1, foo2 and foo3
} yield ()

用于{
f1不需要双精度，只需
val f=for{{谢谢你的建议。所以我不做嵌套for循环。这很好。但我还想要一个功能，我有第三个未来，这取决于foo未来。如果foo未来正在完成，那么第三个未来正在开始。我是怎么做的？你的意思是当
foo
完成时，第二个和第三个未来应该同时开始吗？是的。所以我有4期货，比如foo1、foo2、foo3和foo4。所有期货均返回【单位】。当没有依赖项时，我使用理解来逐个执行它们。但是，比如说，foo4依赖于foo3，foo3依赖于foo2，后者依赖于foo1。现在如何在for循环中写入此内容？对不起，先生，函数无法接受参数。这是我的问题。这非常困难。没关系，您可以为理解创建未来的特别内部离子。
for {
  f1 <- foo1()
  f2 <- foo2(f1)
  f3 <- foo3(f2)
  _  <- Future{f1 + f2 + f3} //depends on foo1, foo2 and foo3
} yield ()