Scala对未来的“理解”

Question

我正在阅读Scala Cookbook（http://shop.oreilly.com/product/0636920026914.do）

有一个与未来使用相关的例子，涉及理解。

到目前为止，我对理解的理解是，当与一个集合一起使用时，它会产生另一个相同类型的集合。例如，如果每个< code>futureX的类型为< code>Future[Int]，则以下内容也应为< code>Future[Int]类型:

for {
   r1 <- future1
   r2 <- future2
   r3 <- future3
} yield (r1+r2+r3)

有人能解释一下使用时到底发生了什么吗




Answer 1

如果可能的话，它允许r1、r2和r3并行运行。这可能是不可能的，这取决于有多少线程可用于执行未来的计算，但通过使用此语法，您可以告诉编译器在可能的情况下并行运行这些计算，然后在所有计算完成后执行yield（）。

Answer 2

在这里详细阐述这些现有答案，一个简单的结果来演示理解是如何工作的。

它的功能有点长，但它们值得研究。

一个函数，它给我们一个整数范围

scala> def createIntegers = Future{
             println("INT "+ Thread.currentThread().getName+" Begin.")
             val returnValue = List.range(1, 256)
             println("INT "+ Thread.currentThread().getName+" End.")
             returnValue
         }
createIntegers: createIntegers: scala.concurrent.Future[List[Int]]

给我们一系列字符的函数

scala> def createAsciiChars = Future{
             println("CHAR "+ Thread.currentThread().getName+" Begin.")
             val returnValue = new ListBuffer[Char]
             for (i <- 1 to 256){
                  returnValue += i.toChar
             }
             println("CHAR "+ Thread.currentThread().getName+" End.")
             returnValue
          }
createAsciiChars: scala.concurrent.Future[scala.collection.mutable.ListBuffer[Char]]

为了便于理解，在中使用这些函数调用。

scala> val result = for{
                        i <- createIntegers
                        s <- createAsciiChars
                    } yield i.zip(s)
       Await.result(result, Duration.Inf)
result: scala.concurrent.Future[List[(Int, Char)]] = Future(<not completed>)

对于下面的这些行，我们可以确定所有的函数调用都是同步的，也就是说，在< code>createIntegers完成其执行之前，不会执行< code>createAsciiChars函数调用。

scala> INT scala-execution-context-global-27 Begin.
       INT scala-execution-context-global-27 End.
       CHAR scala-execution-context-global-28 Begin.
       CHAR scala-execution-context-global-28 End.

在< code>for理解之外调用这些函数< code > createscichars 、< code>createIntegers将是异步执行。

Answer 3

首先是理解。在SO上回答了很多很多次，它是对几个一元操作的抽象：map，flatMap，withFilter。当您使用时

r

它看起来像一个命令式计算（monad是关于什么的），您将计算结果绑定到r。产量部分被解压缩到map调用中。结果类型取决于monad的类型。

< code>Future trait有一个< code>flatMap和< code>map函数，所以我们可以用它来理解。在你的例子中可以解糖成下面的代码:

future1.flatMap(r1 => future2.flatMap(r2 => future3.map(r3 => r1 + r2 + r3) ) )

不言而喻，如果未来2的执行取决于r1，则无法避免顺序执行，但如果未来的计算是独立的，则有两种选择。您可以强制顺序执行，也可以允许并行执行。您不能强制后者，因为执行上下文将处理此问题。

val res = for {
   r1 <- computationReturningFuture1(...)
   r2 <- computationReturningFuture2(...)
   r3 <- computationReturningFuture3(...)
} yield (r1+r2+r3)

将始终按顺序运行。它可以很容易地用去加法来解释，之后后续的计算返回未来X调用仅在平面图内部调用，即。

computationReturningFuture1(...).flatMap(r1 => 
    computationReturningFuture2(...).flatMap(r2 => 
        computationReturningFuture3(...).map(r3 => r1 + r2 + r3) ) )

但是，这能够并行运行，并且用于理解聚合结果：

val future1 = computationReturningFuture1(...)
val future2 = computationReturningFuture2(...)
val future3 = computationReturningFuture3(...)

val res = for {
   r1 <- future1
   r2 <- future2
   r3 <- future3
} yield (r1+r2+r3)