评论你的帖子

Question

考虑以下方法......

def doSomething1: Future[Int] = { ... }
def doSomething2: Future[Int] = { ... }
def doSomething3: Future[Int] = { ... }

......以及以下的理解：

for {
  x <- doSomething1
  y <- doSomething2
  z <- doSomething3
} yield x + y + z

这三种方法并行运行，但在我的情况下doSomething2必须在doSomething1完成后运行。如何按顺序运行这三种方法？

修改

根据Philosophus42的建议，以下是doSomething1的可能实现方式：

def doSomething1: Future[Int] = {
  // query the database for customers younger than 40;
  // `find` returns a `Future` containing the number of matches
  customerService.find(Json.obj("age" -> Json.obj("$lt" -> 40)))
}

...所以Future是由对另一个方法的内部调用创建的。

编辑2

也许我过分简化了用例......我很抱歉。让我们再试一次，更接近真实的用例。以下是三种方法：

for {
  // get all the transactions generated by the exchange service
  transactions <- exchange.orderTransactions(orderId)

  //for each transaction create a log
  logs <- Future.sequence(tansactions.map { transaction =>
    for {
      // update trading order status
      _ <- orderService.findAndUpdate(transaction.orderId, "Executed")

      // create new log
      log <- logService.insert(Log(
        transactionId => transaction.id,
        orderId => transaction.orderId,
        ...
      ))
    } yield log
  })
} yield logs

我要做的是为与订单关联的每笔交易创建一个日志。即使logService.insert只包含一个条目，transactions也会被多次调用。

Answer 1

评论你的帖子

首先，doSomethingX中的代码如何？更加不合理的是，使用您给定的代码，期货并行运行。

答案

为了使Future执行顺序，只需使用

for {
  v1 <- Future { ..block1... } 
  v2 <- Future { ..block2... } 
} yield combine(v1, v2)

这个工作的原因是，语句Future {..body ..}启动异步计算，在那个时间点评估语句。

以上为理解的desugared

Future { ..block1.. }
  .flatMap( v1 => 
     Future { ..block>.. }
       .map( v2 => combine(v1,v2) )
  )

很明显，

如果Future{ ...block1... }有结果，
触发flatMap方法，
然后触发执行Future { ...block2... }。

因此Future { ...block2... }在 Future { ...block1... }

之后执行
其他信息

A Future

Future { <block> }

立即通过ExecutionContext
触发执行包含的阻止
摘录1：

val f1 = Future { <body> } val f2 = Future { <otherbody> }

这两个计算是并行运行的（如果你的ExecutionContext是这样设置的），因为这两个值是立即评估的。

摘录2：

构造

def f1 = Future { ..... }
一旦调用f1
，
将开始执行未来
修改

j3d，我仍然感到困惑，为什么你的代码没有按预期工作，如果你的陈述是正确的，那么Future 是在 computeSomethingX方法中创建的。

以下是一段代码片段，证明computeSomething2
后执行computeSomething1
import scala.concurrent。{Await，Future} import scala.concurrent.duration ._

object Playground { import scala.concurrent.ExecutionContext.Implicits.global def computeSomething1 : Future[Int] = { Future { for (i <- 1 to 10) { println("computeSomething1") Thread.sleep(500) } 10 } } def computeSomething2 : Future[String] = { Future { for(i <- 1 to 10) { println("computeSomething2") Thread.sleep(800) } "hello" } } def main(args: Array[String]) : Unit = { val resultFuture: Future[String] = for { v1 <- computeSomething1 v2 <- computeSomething2 } yield v2 + v1.toString // evil "wait" for result val result = Await.result(resultFuture, Duration.Inf) println( s"Result: ${result}") } }

带输出

computeSomething1 computeSomething1 computeSomething1 computeSomething1 computeSomething1 computeSomething1 computeSomething1 computeSomething1 computeSomething1 computeSomething1 computeSomething2 computeSomething2 computeSomething2 computeSomething2 computeSomething2 computeSomething2 computeSomething2 computeSomething2 computeSomething2 computeSomething2 Result: hello10

修改2

如果您希望它们以并行执行，请事先创建未来（此处为f1和f2）

def main(args: Array[String]) : Unit = { val f1 = computeSomething1 val f2 = computeSomething2 val resultFuture: Future[String] = for { v1 <- f1 v2 <- f2 } yield v2 + v1.toString // evil "wait" for result val result = Await.result(resultFuture, Duration.Inf) println( s"Result: ${result}") }

Answer 2

我看到两个变种来实现这个目标：

<强>首先：确保在理解范围内创建期货。这意味着您的函数应该像这样定义：def doSomething1: Future[Int] = Future { ... }。在这种情况下，for comprehension应按顺序执行Futures。

<强>第二使用您需要在其他人开始之前完成的Future的地图功能：

doSomething1.map{ i =>
  for {
  y <- doSomething2
  z <- doSomething3
  } yield i + y + z
}

为了理解：如何顺序运行期货

2 个答案:

评论你的帖子

答案

其他信息