爲什麼新的線程，而不是未來{...}

Question

This answer指示如何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 

我queston是相同的意見提出的問題：

future { jfuture.get }有什麼不對？爲什麼你使用一個額外的線程與Promise結合？

有人回答如下：

它會阻止你的拉線線程。如果你爲這樣的期貨有一個配置好的ExecutionContext，那沒問題，但是默認的ExecutionContext包含與你有處理器一樣多的線程。

我不確定我是否理解說明。重申：

future { jfuture.get }怎麼了？未來是否會像手動創建新線程一樣阻塞，並阻止它？如果不是，它有什麼不同？

Answer 1

future { jfuture.get }和future { future { jfuture.get }}之間幾乎沒有區別。

默認線程池中有許多處理器的處理器。

隨着jfuture.get你會得到1個線程被阻止。

假設您有8個處理器。我們假設每個jfuture.get需要10秒。現在創建8 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 

對於2+2評估，10秒有點過長。

所有其他future s和同一個執行上下文中的所有actor將被停止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 {...blockingFuture，但額外的執行上下文，可以限制線程數。

Answer 2

其實很簡單。 scala.concurrent.Promise是Future的具體實現，註定是異步計算。

當你想轉換，與jfuture.get，你正在運行阻塞計算和輸出立即解決scala.concurrent.Future。

Thread將會阻塞，直到jfuture內部的計算完成。 get方法正在阻止。

阻塞意味着在Thread之內沒有別的東西會發生，直到計算完成。你基本上壟斷了Thread，看起來像一個while循環，間歇性地檢查結果。

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

具體來說：

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

當阻塞不能避免時，通常的做法是產生一個new Thread和new Runnable或new Callable以允許使計算執行/獨佔一個子線程。

在這個例子中@senia了：

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

這怎麼比future {jfuture.get}不同？它不會阻止Scala提供的默認ExecutionContext，它具有與機器處理器一樣多的線程數。

這意味着代碼中的所有其他期貨將始終需要等待future { jfuture.get }完成，因爲整個上下文都被阻止。