Какая разница между Execution Context SCALA и пьесы Контекст выполнения

Question

Scala имеет свой контекст исполнения, как

import scala.concurrent.ExecutionContext.Implicits.global 

Ans Play имеет свой собственный контекст исполнения

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

Что является главным отличием и который один мы должны использовать и в котором сенарио.

Answer 1

scala.concurrent.ExecutionContext.Implicits.global (контекст выполнения сценария stala) - это контекст выполнения, предоставляемый стандартной библиотекой scala. Это специальный ForkJoinPool, который использует метод блокировки для обработки потенциально блокирующего кода для создания новых потоков в пуле. Вы не должны использовать это в игровом приложении, так как игра не будет иметь никакого контроля над ним. Где в качестве 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()) 

Когда приложение не использует нулевой 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 
     } 
    }) 
    }