为什么是新线程而不是未来 {...}

Question

此答案指示如何将java.util.concurrent.Future转换为scala.concurrent.Future，同时管理将发生阻塞的位置：

import java.util.concurrent.{Future => JFuture}
import scala.concurrent.{Future => SFuture}

val jfuture: JFuture[T] = ???
val promise = Promise[T]()
new Thread(
  new Runnable {
    def run() { promise.complete(Try{ jfuture.get }) }
  }
).start
val future = promise.future

我的问题和评论中的问题一样:

Future{jfuture.get}怎么了？为什么你使用一个额外的线程与Promise结合？

答复如下：

它会在你拉线的时候卡住线。如果您已经为这样的未来配置了ExecutionContext，这很好，但是默认的ExecutionContext包含的线程与您拥有的处理器一样多。

我不确定我是否理解这个解释。重申:

Future{jfuture.get}有什么问题？在未来内部阻塞不是和手动创建一个新线程并在那里阻塞一样吗？如果不是，有什么不同？

Answer 1

其实挺简单的。< code > Scala . concurrent . promise 是< code>Future的具体实现，注定是异步计算。

当你想要转换时，使用jfuture.get，你正在运行一个阻塞计算，并输出一个立即解析的scala.concurrent.Future。

< code >线程将阻塞，直到< code>jfuture内的计算完成。< code>get方法被阻止。

阻塞意味着在计算完成之前，线程内不会发生任何其他事情。在循环间歇检查结果时，您基本上垄断了线程。

while (!isDone() && !timeout) {
   // check if the computation is complete
}

具体来说:

val jfuture: JFuture[T] = ??? // some blocking task

当无法避免阻塞时，通常的做法是生成一个新线程和一个新可运行或new可调用，以允许计算执行/独占子线程。

在@senia给出的例子中:

new Thread(new Runnable { def run() {
  promise.complete(Try{ jfuture.get })
}}).start

这与未来{jfuture.get}有何不同？它不会阻止Scala提供的默认执行上下文，Scala的线程数与机器处理器的线程数相同。

这意味着代码中的所有其他未来都必须等待未来{jfuture.get}完成，因为整个上下文都被阻塞了。

Answer 2

future { jfuture.get } 和 future { future { jfuture.get }} 之间几乎没有区别。

默认线程池中的胎面数量与处理器数量一样多。

使用< code>jfuture.get,您将有1个线程被阻塞。

假设您有8个处理器。我们还假设每个< code>jfuture.get需要10秒钟。现在创建8 < code > future { jfuture . get } 。

val format = new java.text.SimpleDateFormat("HH:mm:ss").format(_: Date)

val startTime = new Date
(1 to 8) map {_ => future{ Thread.sleep(10000) }}
future{
  2+2
  println(s"2+2 done. Start time: ${format(startTime)}, end time: ${format(new Date)}")
}

// 2+2 done. Start time: 20:48:18, end time: 20:48:28

10秒对于2 2评估来说有点长。

同一执行上下文中的所有其他< code>future和所有参与者将停止10秒钟。

使用附加执行上下文：

object BlockingExecution {
  val executor = ExecutionContext.fromExecutor(new ForkJoinPool(20))
}

def blockingFuture[T](f: => T) = {
  future( f )(BlockingExecution.executor)
}

val startTime = new Date
(1 to 8) map {_ => blockingFuture{ Thread.sleep(10000) }}
future{
  2+2
  println(s"2+2 done. Start time: ${format(startTime)}, end time: ${format(new Date)}")
}

// 2+2 done. Start time: 21:26:18, end time: 21:26:18

您可以使用new Thread（new Runnable {...）来实现阻塞未来，但额外的执行上下文允许您限制线程计数。