Extensions

Schedules the given callback for asynchronous execution in the thread-pool.

On Scala < 2.12 it is described as a macro, so it has zero overhead, being perfectly equivalent with execute(new Runnable { ... }).

On Scala 2.12 because of the Java 8 SAM types integration, this extension macro is replaced with a method that takes a plain Runnable as parameter.

Schedules the given callback for asynchronous execution in the thread-pool, but also indicates the start of a thread-local trampoline in case the scheduler is a BatchingScheduler.

This utility is provided as an optimization. If you don't understand what this does, then don't worry about it.

On Scala < 2.12 it is described as a macro, so it has zero overhead. On Scala 2.12 because of the Java 8 SAM types integration, this extension macro is replaced with a method that takes a plain TrampolinedRunnable as parameter.

Schedules the given callback for immediate execution as a TrampolinedRunnable. Depending on the execution context, it might get executed on the current thread by using an internal trampoline, so it is still safe from stack-overflow exceptions.

On Scala < 2.12 it is described as a macro, so it has zero overhead, being perfectly equivalent with execute(new TrampolinedRunnable { ... }).

On Scala 2.12 because of the Java 8 SAM types integration, this extension macro is replaced with a method that takes a plain TrampolinedRunnable as parameter.

Schedules a periodic task that becomes enabled first after the given initial delay, and subsequently with the given period. Executions will commence after initialDelay then initialDelay + period, then initialDelay + 2 * period and so on.

If any execution of the task encounters an exception, subsequent executions are suppressed. Otherwise, the task will only terminate via cancellation or termination of the scheduler. If any execution of this task takes longer than its period, then subsequent executions may start late, but will not concurrently execute.

For example the following schedules a message to be printed to standard output approximately every 10 seconds with an initial delay of 5 seconds:

val task = scheduler.scheduleAtFixedRate(5.seconds, 10.seconds) {
  print("Repeated message")
}

// later if you change your mind ...
task.cancel()

Schedules a task to run in the future, after initialDelay.

For example the following schedules a message to be printed to standard output after 5 minutes:

val task = scheduler.scheduleOnce(5.minutes) {
  print("Hello, world!")
}

// later, if you change your mind ...
task.cancel()

Schedules for execution a periodic task that is first executed after the given initial delay and subsequently with the given delay between the termination of one execution and the commencement of the next.

For example the following schedules a message to be printed to standard output every 10 seconds with an initial delay of 5 seconds:

val task = s.scheduleWithFixedDelay(5.seconds, 10.seconds) {
  print("Repeated message")
}

// later if you change your mind ...
task.cancel()

DEPRECATED — use clockRealTime(MILLISECONDS).