Question

我有问题。我需要一个未来来等待其他未来完成后再运行。我的编码是这样的：

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()
    }
  }

}

运行此程序时，我什么也看不到。怎么了？而且for循环看起来很糟糕。请提供有关好的解决方案的建议。

Answer 1

对Scala的未来进行了积极的评估，没有简单的方法可以使它们变得懒惰。一种方法是将将来的创建包装在函数中，而这就是您要做的事情，因此您的问题与之无关。

您做错了，是您开始期货，但是您不必等待它们，您的申请就可以在其评估结束之前完成。您必须在Await.result方法的末尾添加main。

您不必要做的另一件事是嵌套以获取理解。用于理解的每个调用都是顺序执行的（转换为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)
}

比方说，您需要创建execute，其中一个依赖于另一个：

def foo1(): Future[String] = ???
def foo2(foo1: String): Future[String] = ??? //foo2 depends on foo1
def foo3(foo2: String): Future[String] = ??? //foo3 depends on foo2

就这么简单：

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

让一个未来在等待另一个未来

1 个答案: