LightArrayRevolverScheduler, see #2904

- based on a wheel (AtomicReferenceArray) from which atomic
  single-linked lists dangle
- no locks
- deterministic tests due to overridable time source
- also bring docs up to date

akka-docs/rst/scala/code/docs/actor/SchedulerDocSpec.scala

@@ -29,7 +29,7 @@ class SchedulerDocSpec extends AkkaSpec(Map("akka.loglevel" -> "INFO")) {
     expectMsg(1 second, "foo")
 
     //#schedule-one-off-thunk
-    //Schedules a function to be executed (send the current time) to the testActor after 50ms
+    //Schedules a function to be executed (send a message to the testActor) after 50ms
     system.scheduler.scheduleOnce(50 milliseconds) {
       testActor ! System.currentTimeMillis
     }

akka-docs/rst/scala/scheduler.rst

@@ -5,22 +5,23 @@
  Scheduler (Scala)
 ###################
 
-Sometimes the need for making things happen in the future arises, and where do you go look then?
-Look no further than ``ActorSystem``! There you find the :meth:`scheduler` method that returns an instance
-of akka.actor.Scheduler, this instance is unique per ActorSystem and is used internally for scheduling things
-to happen at specific points in time. Please note that the scheduled tasks are executed by the default
-``MessageDispatcher`` of the ``ActorSystem``.
+Sometimes the need for making things happen in the future arises, and where do
+you go look then?  Look no further than ``ActorSystem``! There you find the
+:meth:`scheduler` method that returns an instance of
+:class:`akka.actor.Scheduler`, this instance is unique per ActorSystem and is
+used internally for scheduling things to happen at specific points in time.
 
-You can schedule sending of messages to actors and execution of tasks (functions or Runnable).
-You will get a ``Cancellable`` back that you can call :meth:`cancel` on to cancel the execution of the
-scheduled operation.
+You can schedule sending of messages to actors and execution of tasks
+(functions or Runnable).  You will get a ``Cancellable`` back that you can call
+:meth:`cancel` on to cancel the execution of the scheduled operation.
 
 .. warning::
 
-    The default implementation of ``Scheduler`` used by Akka is based on the Netty ``HashedWheelTimer``.
-    It does not execute tasks at the exact time, but on every tick, it will run everything that is overdue.
-    The accuracy of the default Scheduler can be modified by the "ticks-per-wheel" and "tick-duration" configuration
-    properties. For more information, see: `HashedWheelTimers <http://www.cse.wustl.edu/~cdgill/courses/cs6874/TimingWheels.ppt>`_.
+    The default implementation of ``Scheduler`` used by Akka is based on job
+    buckets which are emptied according to a fixed schedule.  It does not
+    execute tasks at the exact time, but on every tick, it will run everything
+    that is (over)due.  The accuracy of the default Scheduler can be modified
+    by the ``akka.scheduler.tick-duration`` configuration property.
 
 Some examples
 -------------
@@ -44,16 +45,26 @@ From ``akka.actor.ActorSystem``
 The Scheduler interface
 -----------------------
 
+The actual scheduler implementation is loaded reflectively upon
+:class:`ActorSystem` start-up, which means that it is possible to provide a
+different one using the ``akka.scheduler.implementation`` configuration
+property. The referenced class must implement the following interface:
+
 .. includecode:: ../../../akka-actor/src/main/scala/akka/actor/Scheduler.scala
    :include: scheduler
 
 The Cancellable interface
 -------------------------
 
-This allows you to ``cancel`` something that has been scheduled for execution.
+Scheduling a task will result in a :class:`Cancellable` (or throw an
+:class:`IllegalStateException` if attempted after the scheduler’s shutdown).
+This allows you to cancel something that has been scheduled for execution.
 
 .. warning::
-  This does not abort the execution of the task, if it had already been started.
+
+  This does not abort the execution of the task, if it had already been
+  started.  Check the return value of ``cancel`` to detect whether the
+  scheduled task was canceled or will (eventually) have run.
 
 .. includecode:: ../../../akka-actor/src/main/scala/akka/actor/Scheduler.scala
    :include: cancellable