Add some ExecutionContext factories.

4 files changed, 30 insertions, 16 deletions

diff --git a/src/library/scala/collection/parallel/TaskSupport.scala b/src/library/scala/collection/parallel/TaskSupport.scala
index 59b75f523f..2eaa861429 100644
--- a/src/library/scala/collection/parallel/TaskSupport.scala
+++ b/src/library/scala/collection/parallel/TaskSupport.scala
@@ -48,7 +48,7 @@ extends TaskSupport with AdaptiveWorkStealingThreadPoolTasks
  *  By default, parallel collections are parametrized with this task support object, so parallel collections
  *  share the same execution context backend as the rest of the `scala.concurrent` package.
  */
-class ExecutionContextTaskSupport(val environment: ExecutionContext = scala.concurrent.executionContext)
+class ExecutionContextTaskSupport(val environment: ExecutionContext = scala.concurrent.defaultExecutionContext)
 extends TaskSupport with ExecutionContextTasks
 
 
diff --git a/src/library/scala/concurrent/ConcurrentPackageObject.scala b/src/library/scala/concurrent/ConcurrentPackageObject.scala
index 0f882540f2..d185ade8a4 100644
--- a/src/library/scala/concurrent/ConcurrentPackageObject.scala
+++ b/src/library/scala/concurrent/ConcurrentPackageObject.scala
@@ -20,8 +20,7 @@ import ConcurrentPackageObject._
 abstract class ConcurrentPackageObject {
   /** A global execution environment for executing lightweight tasks.
    */
-  lazy val executionContext =
-    new impl.ExecutionContextImpl()
+  lazy val defaultExecutionContext = new impl.ExecutionContextImpl(null)
 
   private val currentExecutionContext = new ThreadLocal[ExecutionContext]
   
@@ -42,7 +41,7 @@ abstract class ConcurrentPackageObject {
     case Left(t: scala.util.control.ControlThrowable)    => Left(new ExecutionException("Boxed ControlThrowable", t))
     case Left(t: InterruptedException)                   => Left(new ExecutionException("Boxed InterruptedException", t))
     case Left(e: Error)                                  => Left(new ExecutionException("Boxed Error", e))
-    case _                                                  => source
+    case _                                               => source
   }
 
   private[concurrent] def resolver[T] =
@@ -50,10 +49,10 @@ abstract class ConcurrentPackageObject {
 
   /* concurrency constructs */
 
-  def future[T](body: =>T)(implicit execctx: ExecutionContext = executionContext): Future[T] =
+  def future[T](body: =>T)(implicit execctx: ExecutionContext = defaultExecutionContext): Future[T] =
     Future[T](body)
 
-  def promise[T]()(implicit execctx: ExecutionContext = executionContext): Promise[T] =
+  def promise[T]()(implicit execctx: ExecutionContext = defaultExecutionContext): Promise[T] =
     Promise[T]()
 
   /** Wraps a block of code into an awaitable object. */
diff --git a/src/library/scala/concurrent/ExecutionContext.scala b/src/library/scala/concurrent/ExecutionContext.scala
index 16d9a1f980..e1d4276396 100644
--- a/src/library/scala/concurrent/ExecutionContext.scala
+++ b/src/library/scala/concurrent/ExecutionContext.scala
@@ -11,7 +11,7 @@ package scala.concurrent
 
 
 import java.util.concurrent.atomic.{ AtomicInteger }
-import java.util.concurrent.{ Executors, Future => JFuture, Callable }
+import java.util.concurrent.{ Executors, Future => JFuture, Callable, ExecutorService, Executor }
 import scala.concurrent.util.Duration
 import scala.concurrent.forkjoin.{ ForkJoinPool, RecursiveTask => FJTask, RecursiveAction, ForkJoinWorkerThread }
 import scala.collection.generic.CanBuildFrom
@@ -36,5 +36,20 @@ trait ExecutionContext {
 }
 
 
+/** Contains factory methods for creating execution contexts.
+ */
+object ExecutionContext {
+  
+  implicit def defaultExecutionContext: ExecutionContext = scala.concurrent.defaultExecutionContext
+  
+  /** Creates an `ExecutionContext` from the given `ExecutorService`.
+   */
+  def fromExecutorService(e: ExecutorService): ExecutionContext with Executor = new impl.ExecutionContextImpl(e)
+  
+  /** Creates an `ExecutionContext` from the given `Executor`.
+   */
+  def fromExecutor(e: Executor): ExecutionContext with Executor = new impl.ExecutionContextImpl(e)
+  
+}
 
 
diff --git a/src/library/scala/concurrent/impl/ExecutionContextImpl.scala b/src/library/scala/concurrent/impl/ExecutionContextImpl.scala
index 9a94bfca4f..52c834359d 100644
--- a/src/library/scala/concurrent/impl/ExecutionContextImpl.scala
+++ b/src/library/scala/concurrent/impl/ExecutionContextImpl.scala
@@ -10,20 +10,20 @@ package scala.concurrent.impl
 
 
 
-import java.util.concurrent.{Callable, ExecutorService, Executors, ThreadFactory}
+import java.util.concurrent.{Callable, Executor, ExecutorService, Executors, ThreadFactory}
 import scala.concurrent.forkjoin._
 import scala.concurrent.{ExecutionContext, resolver, Awaitable, body2awaitable}
 import scala.concurrent.util.{ Duration }
 
 
 
-private[scala] class ExecutionContextImpl() extends ExecutionContext {
+private[scala] class ExecutionContextImpl(es: AnyRef) extends ExecutionContext with Executor {
   import ExecutionContextImpl._
   
-  val executorService: AnyRef = getExecutorService
+  val executorService: AnyRef = if (es eq null) getExecutorService else es
   
   // to ensure that the current execution context thread local is properly set
-  private def executorsThreadFactory = new ThreadFactory {
+  def executorsThreadFactory = new ThreadFactory {
     def newThread(r: Runnable) = new Thread(new Runnable {
       override def run() {
         currentExecutionContext.set(ExecutionContextImpl.this)
@@ -33,7 +33,7 @@ private[scala] class ExecutionContextImpl() extends ExecutionContext {
   }
   
   // to ensure that the current execution context thread local is properly set
-  private def forkJoinPoolThreadFactory = new ForkJoinPool.ForkJoinWorkerThreadFactory {
+  def forkJoinPoolThreadFactory = new ForkJoinPool.ForkJoinWorkerThreadFactory {
     def newThread(fjp: ForkJoinPool) = new ForkJoinWorkerThread(fjp) {
       override def onStart() {
         currentExecutionContext.set(ExecutionContextImpl.this)
@@ -41,7 +41,7 @@ private[scala] class ExecutionContextImpl() extends ExecutionContext {
     }
   }
   
-  private def getExecutorService: AnyRef =
+  def getExecutorService: AnyRef =
     if (scala.util.Properties.isJavaAtLeast("1.6")) {
       val vendor = scala.util.Properties.javaVmVendor
       if ((vendor contains "Oracle") || (vendor contains "Sun") || (vendor contains "Apple"))
@@ -62,8 +62,8 @@ private[scala] class ExecutionContextImpl() extends ExecutionContext {
       } else {
         fj.execute(runnable)
       }
-    case executorService: ExecutorService =>
-      executorService execute runnable
+    case executor: Executor =>
+      executor execute runnable
   }
 
   def execute[U](body: () => U): Unit = execute(new Runnable {
@@ -86,7 +86,7 @@ private[scala] class ExecutionContextImpl() extends ExecutionContext {
 
 object ExecutionContextImpl {
 
-  private[concurrent] def currentExecutionContext: ThreadLocal[ExecutionContextImpl] = new ThreadLocal[ExecutionContextImpl] {
+  private[concurrent] def currentExecutionContext: ThreadLocal[ExecutionContext] = new ThreadLocal[ExecutionContext] {
     override protected def initialValue = null
   }