ブロッキングが発生する場所を管理しながら、代わりに将来{...}

Question

This answerの新しいスレッドは、scala.concurrent.Futureにjava.util.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と、同じ実行コンテキストのすべてのアクタが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をブロックするものではありません。Scalaでは、マシンのプロセッサーと同じ数のスレッドがあります。

これは、コンテキスト全体がブロックされているため、コード内の他のすべての未来が常にfuture { jfuture.get }が完了するまで待つ必要があることを意味します。