在 Scala 中混合同步、异步和并行计算以理解未来的最惯用方式

Question

假设我有 4 个未来的计算要做。前两个可以并行完成，但第三个必须在前两个之后完成（即使前两个的值没有在第三个中使用——将每个计算视为执行某些 db 操作的命令）。最后，在前 3 次计算之后必须进行第 4 次计算。此外，还有一个副作用，可以在前 3 次完成后开始（将其视为启动周期性可运行文件）。在代码中，这可能如下所示：

for {
  _ <- async1     // not done in parallel with async2 :( is there
  _ <- async2     // any way of achieving this cleanly inside of for?
  _ <- async3
  _ =  sideEffect // do I need "=" here??
  _ <- async4
} yield ()

cmets 表明我对代码质量的怀疑：

1. 在 for 理解中并行执行两个操作的最简洁方法是什么？
2. 有没有一种方法可以在没有这么多“_”字符的情况下实现此结果（也没有分配命名引用，至少在 sideEffect 的情况下）
3. 最干净、最惯用的方法是什么？

Answer 1

您可以使用zip 组合两个期货，包括zip 本身的结果。您最终会得到包含元组的元组，但是如果您对 Tuple2 使用中缀表示法，则很容易将它们分开。下面我为简洁定义了一个同义词~（这是解析器组合库所做的，除了它的~ 是一个与Tuple2 类似的不同类）。

作为替代_ = 的副作用，您可以将其移至yield，或使用大括号和分号将其与以下语句组合。我仍然认为_ = 更惯用，至少就for 中的副作用声明而言是惯用的。

val ~ = Tuple2

for {
  a ~ b ~ c <- async1 zip
               async2 zip
               async3
  d <- { sideEffect; async4 }
} yield (a, b, c, d)

Answer 2

for-comprehensions 表示一元操作，一元操作是有序的。 monad 的超类 applicative，其计算不依赖于先前计算的结果，因此可以并行运行。

Scalaz 有一个 |@| 运算符用于组合应用程序，因此您可以使用 (future1 |@| future2)(proc(_, _)) 并行调度两个期货，然后对它们的结果运行“proc”，而不是 for {a <- future1; b <- future2(a)} yield b 的顺序计算（或只是future1 flatMap future2）。

stdlib Futures 上已经有一个名为 .zip 的方法，它可以并行组合 Futures，而 scalaz impl 确实使用了这个方法：https://github.com/scalaz/scalaz/blob/scalaz-seven/core/src/main/scala/scalaz/std/Future.scala#L36 并且 .zip 和 for-comprehensions 可以混合使用以具有并行和连续的部分，视情况而定。 因此，只需使用 stdlib 语法，您上面的示例就可以写成：

for {
  _ <- async1 zip async2
  _ <- async3
  _ =  sideEffect
  _ <- async4
} yield ()

或者，写成没有理解：

async1 zip async2 flatMap (_=> async3) flatMap {_=> sideEffect; async4}

Answer 3

仅供参考，让两个期货并行运行并仍然通过理解来处理它们非常简单。使用zip 的建议解决方案当然可以，但是我发现当我想处理几个期货并在它们都完成后做某事时，并且我有两个或更多彼此独立的，我会做一些事情像这样：

val f1 = async1
val f2 = async2
//First two futures now running in parallel

for {
  r1 <- f1     
  r2 <- f2     
  _ <- async3
  _ =  sideEffect 
  _ <- async4
} yield {
  ...
}

现在 for 理解的结构方式在检查 f2 的完成状态之前肯定会等待 f1，但是这两个期货背后的逻辑是同时运行的。这比一些建议要简单一些，但仍然可以满足您的需求。

Answer 4

您的代码看起来已经结构化减去并行计算期货。

1. 使用辅助函数，最好写一个代码生成器打印出来 所有元组案例的助手
2. 据我所知，你需要为结果命名或赋值_
3. 示例代码

带有帮助器的示例代码。

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

object Example {
  def run: Future[Unit] = {
    for {
      (a, b, c) <- par(
        Future.successful(1),
        Future.successful(2),
        Future.successful(3)
      )
      constant = 100
      (d, e) <- par(
        Future.successful(a + 10),
        Future.successful(b + c)
      )
    } yield {
      println(constant)
      println(d)
      println(e)
    }
  }

  def par[A,B](a: Future[A], b: Future[B]): Future[(A, B)] = {
    for {
      a <- a
      b <- b
    } yield (a, b)
  }

  def par[A,B,C](a: Future[A], b: Future[B], c: Future[C]): Future[(A, B, C)] = {
    for {
      a <- a
      b <- b
      c <- c
    } yield (a, b, c)
  }
}
Example.run

编辑：

为 1 到 20 个期货生成代码：https://gist.github.com/nanop/c448db7ac1dfd6545967#file-parhelpers-scala

parPrinter 脚本：https://gist.github.com/nanop/c448db7ac1dfd6545967#file-parprinter-scala