Add global scheduler with default implementation

3 files changed, 109 insertions, 3 deletions

diff --git a/src/library/scala/concurrent/Scheduler.scala b/src/library/scala/concurrent/Scheduler.scala
new file mode 100644
index 0000000000..39d798e6b4
--- /dev/null
+++ b/src/library/scala/concurrent/Scheduler.scala
@@ -0,0 +1,54 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala API                            **
+**    / __/ __// _ | / /  / _ |    (c) 2003-2011, LAMP/EPFL             **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+\*                                                                      */
+
+package scala.concurrent
+
+import scala.util.Duration
+
+/** A service for scheduling tasks and thunks for one-time, or periodic execution.
+ */
+trait Scheduler {
+
+  /** Schedules a thunk for repeated execution with an initial delay and a frequency.
+   *
+   *  @param delay      the initial delay after which the thunk should be executed
+   *                    the first time
+   *  @param frequency  the frequency with which the thunk should be executed,
+   *                    as a time period between subsequent executions
+   */
+  def schedule(delay: Duration, frequency: Duration)(thunk: => Unit): Cancellable
+
+  /** Schedules a task for execution after a given delay.
+   *
+   *  @param delay  the duration after which the task should be executed
+   *  @param task   the task that is scheduled for execution
+   *  @return       a `Cancellable` that may be used to cancel the execution
+   *                of the task
+   */
+  def scheduleOnce(delay: Duration, task: Runnable): Cancellable
+
+  /** Schedules a thunk for execution after a given delay.
+   *
+   *  @param delay  the duration after which the thunk should be executed
+   *  @param thunk  the thunk that is scheduled for execution
+   *  @return       a `Cancellable` that may be used to cancel the execution
+   *                of the thunk
+   */
+  def scheduleOnce(delay: Duration)(task: => Unit): Cancellable
+
+}
+
+
+
+trait Cancellable {
+
+  /** Cancels the underlying task.
+   */
+  def cancel(): Unit
+
+}
diff --git a/src/library/scala/concurrent/default/SchedulerImpl.scala b/src/library/scala/concurrent/default/SchedulerImpl.scala
new file mode 100644
index 0000000000..745d2d1a15
--- /dev/null
+++ b/src/library/scala/concurrent/default/SchedulerImpl.scala
@@ -0,0 +1,44 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala API                            **
+**    / __/ __// _ | / /  / _ |    (c) 2003-2011, LAMP/EPFL             **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+\*                                                                      */
+
+package scala.concurrent
+package default
+
+import scala.util.Duration
+
+private[concurrent] final class SchedulerImpl extends Scheduler {
+  private val timer =
+    new java.util.Timer(true) // the associated thread runs as a daemon
+
+  def schedule(delay: Duration, frequency: Duration)(thunk: => Unit): Cancellable = ???
+  
+  def scheduleOnce(delay: Duration, task: Runnable): Cancellable = {
+    val timerTask = new java.util.TimerTask {
+      def run(): Unit =
+        task.run()
+    }
+    timer.schedule(timerTask, delay.toMillis)
+    new Cancellable {
+      def cancel(): Unit =
+        timerTask.cancel()
+    }
+  }
+
+  def scheduleOnce(delay: Duration)(task: => Unit): Cancellable = {
+    val timerTask = new java.util.TimerTask {
+      def run(): Unit =
+        task
+    }
+    timer.schedule(timerTask, delay.toMillis)
+    new Cancellable {
+      def cancel(): Unit =
+        timerTask.cancel()
+    }
+  }
+
+}
diff --git a/src/library/scala/concurrent/package.scala b/src/library/scala/concurrent/package.scala
index fed7f7caf8..a139a6d91f 100644
--- a/src/library/scala/concurrent/package.scala
+++ b/src/library/scala/concurrent/package.scala
@@ -13,17 +13,24 @@ package scala
 
 
 
-/** This package object contains primitives for parallel programming.
+/** This package object contains primitives for concurrent and parallel programming.
  */
 package object concurrent {
   
-  type ExecutionException = java.util.concurrent.ExecutionException
+  type ExecutionException =    java.util.concurrent.ExecutionException
   type CancellationException = java.util.concurrent.CancellationException
-  type TimeoutException = java.util.concurrent.TimeoutException
+  type TimeoutException =      java.util.concurrent.TimeoutException
   
+  /** A global execution environment for executing lightweight tasks.
+   */
   lazy val executionContext =
     new default.ExecutionContextImpl
   
+  /** A global service for scheduling tasks for execution.
+   */
+  lazy val scheduler =
+    new default.SchedulerImpl
+
   private[concurrent] def currentExecutionContext: ThreadLocal[ExecutionContext] = new ThreadLocal[ExecutionContext] {
     override protected def initialValue = null
   }
@@ -85,6 +92,7 @@ package object concurrent {
 }
 
 
+
 package concurrent {
   
   /** A timeout exception.