0

Scala には実行コンテキストがあります。

import scala.concurrent.ExecutionContext.Implicits.global

Ans Play には独自の実行コンテキストがあります

import play.api.libs.concurrent.Execution.Implicits.defaultContext

主な違いは何ですか。どちらを使用する必要があり、どのシナリオで使用する必要がありますか。

4

1 に答える 1

3

scala.concurrent.ExecutionContext.Implicits.global(Scala std lib execution context) は、標準 scala ライブラリが提供する実行コンテキストです。これは、ブロッキング メソッドを使用して潜在的なブロッキング コードを処理し、プール内に新しいスレッドを生成する特殊な ForkJoinPool です。play はこれを制御できないため、play アプリケーション内でこれを使用しないでください。where as play.api.libs.concurrent.Execution.Implicits.defaultContext(実行コンテキストの再生) は を使用しactor dispatcherます。これは、再生アプリケーションに使用する必要があるものです。また、ブロッキング呼び出しを play 実行コンテキスト以外の別の実行コンテキストにオフロードすることをお勧めします。このようにして、プレイアプリが飢餓状態になるのを防ぎます。

実行コンテキストの実装を再生するplay.api.libs.concurrent.Execution.Implicits.defaultContext

 val appOrNull: Application = Play._currentApp
 appOrNull match {
  case null => common
  case app: Application => app.actorSystem.dispatcher
 }

 private val common = ExecutionContext.fromExecutor(new ForkJoinPool())

app が null でない場合、使用しますactorSystem.dispatcher

Scala 標準の実行コンテキスト。

val executor: Executor = es match {
    case null => createExecutorService
    case some => some
  }

このメソッドは、構成を考慮available processorsして読み取るエグゼキュータ サービスを作成します。

  def createExecutorService: ExecutorService = {

    def getInt(name: String, default: String) = (try System.getProperty(name, default) catch {
      case e: SecurityException => default
    }) match {
      case s if s.charAt(0) == 'x' => (Runtime.getRuntime.availableProcessors * s.substring(1).toDouble).ceil.toInt
      case other => other.toInt
    }

    def range(floor: Int, desired: Int, ceiling: Int) = scala.math.min(scala.math.max(floor, desired), ceiling)

    val desiredParallelism = range(
      getInt("scala.concurrent.context.minThreads", "1"),
      getInt("scala.concurrent.context.numThreads", "x1"),
      getInt("scala.concurrent.context.maxThreads", "x1"))

    val threadFactory = new DefaultThreadFactory(daemonic = true)

    try {
      new ForkJoinPool(
        desiredParallelism,
        threadFactory,
        uncaughtExceptionHandler,
        true) // Async all the way baby
    } catch {
      case NonFatal(t) =>
        System.err.println("Failed to create ForkJoinPool for the default ExecutionContext, falling back to ThreadPoolExecutor")
        t.printStackTrace(System.err)
        val exec = new ThreadPoolExecutor(
          desiredParallelism,
          desiredParallelism,
          5L,
          TimeUnit.MINUTES,
          new LinkedBlockingQueue[Runnable],
          threadFactory
        )
        exec.allowCoreThreadTimeOut(true)
        exec
    }
  }

このコードはマネージド ブロッキングを担当します。コード内で が検出されると、新しいスレッドを作成しようとしblockingます。

// Implement BlockContext on FJP threads
  class DefaultThreadFactory(daemonic: Boolean) extends ThreadFactory with ForkJoinPool.ForkJoinWorkerThreadFactory {
    def wire[T <: Thread](thread: T): T = {
      thread.setDaemon(daemonic)
      thread.setUncaughtExceptionHandler(uncaughtExceptionHandler)
      thread
    }

    def newThread(runnable: Runnable): Thread = wire(new Thread(runnable))

    def newThread(fjp: ForkJoinPool): ForkJoinWorkerThread = wire(new ForkJoinWorkerThread(fjp) with BlockContext {
      override def blockOn[T](thunk: =>T)(implicit permission: CanAwait): T = {
        var result: T = null.asInstanceOf[T]
        ForkJoinPool.managedBlock(new ForkJoinPool.ManagedBlocker {
          @volatile var isdone = false
          override def block(): Boolean = {
            result = try thunk finally { isdone = true }
            true
          }
          override def isReleasable = isdone
        })
        result
      }
    })
  }
于 2016-10-28T08:59:17.993 に答える