为什么 scala Await.result 在两次通过相同的未来时在 repl 中超时？

Question

我发现这有点令人困惑。我认为 scala 中的期货是不可变的容器，一旦设置，总是返回相同的值。

所以我有一个未来：

val y = future {Thread.sleep(1000); 1};

现在当我立即（在未来解决之前）将它传递给Await.result 块两次：

Await.result(for (r1 <- y; r2 <- y) yield (r1, r2), 60 seconds)

我收到了TimetoutException。

但是，如果我在未来解决后这样做，一切都会正常工作并按预期返回(1,1)。

这种行为的原因是什么？

编辑： 我正在使用隐式 ExecutionContext.Implicits.global 和 scala.concurrent @ scala 2.10.3

编辑2： 如果我创建另一个未来实例做同样的事情并对它们执行 Await.result ，它不会阻塞。

Answer 1

这似乎是在 REPL 中执行它的工件。 您甚至可以使用 2 个单独的未来实例来重现它，而无需调用 Thread.sleep， 并且只使用预先实现的期货（这意味着甚至没有涉及任何未来线程）。 是的，认真的：

import scala.concurrent._
import duration._
import ExecutionContext.Implicits.global
val x = Future.successful(1)
val y = Future.successful(2)
Await.result(x.flatMap{_ => y.map{ _ => 0 } }, Duration(10, SECONDS)) // triggers a timeout

有趣的是，如果您将最后一行更改为以下内容，这不会触发任何超时：

Await.result(x.flatMap{_ => Future.successful(2).map{ _ => 0 } }, Duration(10, SECONDS))

似乎罪魁祸首是你的整个代码 sn-p，当在 REPL 中进行评估时，实际上是包装在一个对象中。 这意味着这里的x和y实际上是对象的成员，而不是局部变量
更重要的是，对 Await 的调用现在是这个包装对象的构造函数的一部分。 出于某种我尚未调查的原因，似乎是对Await 的调用是在触发阻塞的构造函数中完成的 （您可以通过将此调用包装在一个虚拟类中并对其进行实例化来轻松验证它）。

Answer 2

您不想从类初始化程序启动线程的原因是类加载中的循环会阻塞。 Scala 对象只是在静态块中创建的一个实例。闭包对 y 的引用是一个循环。在 2.11 中，使用 -Yrepl-class-based 来帮助它工作。

当闭包类需要X.z时，让我们检查堆栈跟踪是否挂起：

apm@mara:~$ goof
Welcome to Scala version 2.11.0-RC3 (OpenJDK 64-Bit Server VM, Java 1.7.0_25).
Type in expressions to have them evaluated.
Type :help for more information.

scala> import scala.concurrent._
import scala.concurrent._

scala> import duration._
import duration._

scala> import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.ExecutionContext.Implicits.global

scala> object X { val y = Future { 9 } ; val z = Future { 7 } ; val r = Await.result(for (a <- y; b <- z) yield (a+b), 5.seconds) }
defined object X

scala> X.r
java.lang.NoClassDefFoundError: Could not initialize class $line15.$read$$iw$$iw$$iw$$iw$$iw$$iw$X$
    at $line15.$read$$iw$$iw$$iw$$iw$$iw$$iw$X$$anonfun$3.apply(<console>:14)
    at $line15.$read$$iw$$iw$$iw$$iw$$iw$$iw$X$$anonfun$3.apply(<console>:14)
    at scala.concurrent.Future$$anonfun$flatMap$1.apply(Future.scala:251)
    at scala.concurrent.Future$$anonfun$flatMap$1.apply(Future.scala:249)
    at scala.concurrent.impl.CallbackRunnable.run(Promise.scala:32)
    at scala.concurrent.impl.ExecutionContextImpl$AdaptedForkJoinTask.exec(ExecutionContextImpl.scala:121)
    at scala.concurrent.forkjoin.ForkJoinTask.doExec(ForkJoinTask.java:260)
    at scala.concurrent.forkjoin.ForkJoinPool$WorkQueue.runTask(ForkJoinPool.java:1339)
    at scala.concurrent.forkjoin.ForkJoinPool.runWorker(ForkJoinPool.java:1979)
    at scala.concurrent.forkjoin.ForkJoinWorkerThread.run(ForkJoinWorkerThread.java:107)
java.util.concurrent.TimeoutException: Futures timed out after [5 seconds]
  at scala.concurrent.impl.Promise$DefaultPromise.ready(Promise.scala:219)
  at scala.concurrent.impl.Promise$DefaultPromise.result(Promise.scala:223)
  at scala.concurrent.Await$$anonfun$result$1.apply(package.scala:111)
  at scala.concurrent.BlockContext$DefaultBlockContext$.blockOn(BlockContext.scala:53)
  at scala.concurrent.Await$.result(package.scala:111)
  ... 34 elided

只是为了展示它的工作原理：

apm@mara:~$ goof -Yrepl-class-based
Welcome to Scala version 2.11.0-RC3 (OpenJDK 64-Bit Server VM, Java 1.7.0_25).
Type in expressions to have them evaluated.
Type :help for more information.

scala> import scala.concurrent._
import scala.concurrent._

scala> import duration._
import duration._

scala> import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.ExecutionContext.Implicits.global

scala> object X { val y = Future { 9 } ; val z = Future { 7 } ; val r = Await.result(for (a <- y; b <- z) yield (a+b), 5.seconds) }
defined object X

scala> X.r
res0: Int = 16