|
Scala example source code file (Strategy.scala)
The Strategy.scala Scala example source codepackage scalaz package concurrent import java.util.concurrent.{ScheduledExecutorService, ExecutorService, ThreadFactory, Executors} /** * Evaluate an expression in some specific manner. A typical strategy will schedule asynchronous * evaluation and return a function that, when called, will block until the result is ready. * * Memory consistency effects: Actions in a thread prior to the submission of `a` * to the `Strategy` happen-before any actions taken by `a`, which in turn happen-before * the result is retrieved via returned function. */ trait Strategy { def apply[A](a: => A): () => A } object Strategy extends Strategys trait Strategys extends StrategysLow { /** * Default thread factory to mark all threads as daemon */ val DefaultDaemonThreadFactory = new ThreadFactory { val defaultThreadFactory = Executors.defaultThreadFactory() def newThread(r: Runnable) = { val t = defaultThreadFactory.newThread(r) t.setDaemon(true) t } } /** * The default executor service is a fixed thread pool with N daemon threads, * where N is equal to the number of available processors. */ val DefaultExecutorService: ExecutorService = { Executors.newFixedThreadPool(Runtime.getRuntime.availableProcessors, DefaultDaemonThreadFactory) } /** * Default scheduler used for scheduling the tasks like timeout. */ val DefaultTimeoutScheduler: ScheduledExecutorService = Executors.newScheduledThreadPool(1, DefaultDaemonThreadFactory) /** * A strategy that executes its arguments on `DefaultExecutorService` */ implicit val DefaultStrategy: Strategy = Executor(DefaultExecutorService) } trait StrategysLow { /** * A strategy that evaluates its argument in the current thread. */ implicit val Sequential: Strategy = new Strategy { def apply[A](a: => A) = { val v = a () => v } } import java.util.concurrent.ExecutorService /** * A strategy that evaluates its arguments using an implicit ExecutorService. */ implicit def Executor(implicit s: ExecutorService) = new Strategy { import java.util.concurrent.Callable def apply[A](a: => A) = { val fut = s.submit(new Callable[A] { def call = a }) () => fut.get } } /** * A strategy that performs no evaluation of its argument. */ implicit val Id: Strategy = new Strategy { def apply[A](a: => A) = () => a } /** * A simple strategy that spawns a new thread for every evaluation. */ implicit val Naive: Strategy = new Strategy { def apply[A](a: => A) = { import java.util.concurrent.Callable val thread = java.util.concurrent.Executors.newSingleThreadExecutor val fut = thread.submit(new Callable[A] { def call = a }) thread.shutdown() () => fut.get } } /** * A strategy that evaluates its arguments using the pool of Swing worker threads. */ implicit val SwingWorker: Strategy = new Strategy { import javax.swing.SwingWorker def apply[A](a: => A) = { val worker = new SwingWorker[A, Unit] { def doInBackground = a } worker.execute () => worker.get } } /** * A strategy that evaluates its arguments on the Swing Event Dispatching thread. */ implicit val SwingInvokeLater: Strategy = new Strategy { import javax.swing.SwingUtilities.invokeLater import java.util.concurrent.{Callable, FutureTask} def apply[A](a: => A) = { val task = new FutureTask[A](new Callable[A] { def call = a }) invokeLater(task) () => task.get } } } Other Scala examples (source code examples)Here is a short list of links related to this Scala Strategy.scala source code file: |
... this post is sponsored by my books ... | |
![]() #1 New Release! |
![]() FP Best Seller |
Copyright 1998-2024 Alvin Alexander, alvinalexander.com
All Rights Reserved.
A percentage of advertising revenue from
pages under the /java/jwarehouse
URI on this website is
paid back to open source projects.