All Known Implementing Classes:

AbstractScheduler, AbstractSchedulerBase, ExplicitlyTriggeredScheduler, LightArrayRevolverScheduler
```
public interface Scheduler
```
Schedules a message to be sent repeatedly with an initial delay and frequency. E.g. if you would like a message to be sent immediately and thereafter every 500ms you would set delay=Duration.Zero and interval=Duration(500, TimeUnit.MILLISECONDS)
Java & Scala API

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method	Description
`double`	`maxFrequency()`	The maximum supported task frequency of this scheduler, i.e.
`Cancellable`	`schedule(java.time.Duration initialDelay, java.time.Duration interval, ActorRef receiver, java.lang.Object message, scala.concurrent.ExecutionContext executor, ActorRef sender)`	Schedules a message to be sent repeatedly with an initial delay and frequency.
`Cancellable`	`schedule(java.time.Duration initialDelay, java.time.Duration interval, java.lang.Runnable runnable, scala.concurrent.ExecutionContext executor)`	Schedules a `Runnable` to be run repeatedly with an initial delay and a frequency.
`Cancellable`	`schedule(scala.concurrent.duration.FiniteDuration initialDelay, scala.concurrent.duration.FiniteDuration interval, ActorRef receiver, java.lang.Object message, scala.concurrent.ExecutionContext executor, ActorRef sender)`	Schedules a message to be sent repeatedly with an initial delay and frequency.
`Cancellable`	`schedule(scala.concurrent.duration.FiniteDuration initialDelay, scala.concurrent.duration.FiniteDuration interval, java.lang.Runnable runnable, scala.concurrent.ExecutionContext executor)`	Schedules a `Runnable` to be run repeatedly with an initial delay and a frequency.
`Cancellable`	`schedule(scala.concurrent.duration.FiniteDuration initialDelay, scala.concurrent.duration.FiniteDuration interval, scala.Function0<scala.runtime.BoxedUnit> f, scala.concurrent.ExecutionContext executor)`	Schedules a function to be run repeatedly with an initial delay and a frequency.
`ActorRef`	`schedule$default$6(scala.concurrent.duration.FiniteDuration initialDelay, scala.concurrent.duration.FiniteDuration interval, ActorRef receiver, java.lang.Object message)`
`Cancellable`	`scheduleOnce(java.time.Duration delay, ActorRef receiver, java.lang.Object message, scala.concurrent.ExecutionContext executor, ActorRef sender)`	Schedules a message to be sent once with a delay, i.e.
`Cancellable`	`scheduleOnce(java.time.Duration delay, java.lang.Runnable runnable, scala.concurrent.ExecutionContext executor)`	Schedules a Runnable to be run once with a delay, i.e.
`Cancellable`	`scheduleOnce(scala.concurrent.duration.FiniteDuration delay, ActorRef receiver, java.lang.Object message, scala.concurrent.ExecutionContext executor, ActorRef sender)`	Schedules a message to be sent once with a delay, i.e.
`Cancellable`	`scheduleOnce(scala.concurrent.duration.FiniteDuration delay, java.lang.Runnable runnable, scala.concurrent.ExecutionContext executor)`	Schedules a Runnable to be run once with a delay, i.e.
`Cancellable`	`scheduleOnce(scala.concurrent.duration.FiniteDuration delay, scala.Function0<scala.runtime.BoxedUnit> f, scala.concurrent.ExecutionContext executor)`	Schedules a function to be run once with a delay, i.e.
`ActorRef`	`scheduleOnce$default$5(scala.concurrent.duration.FiniteDuration delay, ActorRef receiver, java.lang.Object message)`

- Method Detail
  - maxFrequency
```
double maxFrequency()
```
    The maximum supported task frequency of this scheduler, i.e. the inverse of the minimum time interval between executions of a recurring task, in Hz.
    
    Returns:
    
    (undocumented)
  - schedule
```
Cancellable schedule(scala.concurrent.duration.FiniteDuration initialDelay,
                     scala.concurrent.duration.FiniteDuration interval,
                     ActorRef receiver,
                     java.lang.Object message,
                     scala.concurrent.ExecutionContext executor,
                     ActorRef sender)
```
    Schedules a message to be sent repeatedly with an initial delay and frequency. E.g. if you would like a message to be sent immediately and thereafter every 500ms you would set delay=Duration.Zero and interval=Duration(500, TimeUnit.MILLISECONDS)
    Java & Scala API
    
    Parameters:
    
    initialDelay - (undocumented)
    
    interval - (undocumented)
    
    receiver - (undocumented)
    
    message - (undocumented)
    
    executor - (undocumented)
    
    sender - (undocumented)
    
    Returns:
    
    (undocumented)
  - schedule
```
Cancellable schedule(java.time.Duration initialDelay,
                     java.time.Duration interval,
                     ActorRef receiver,
                     java.lang.Object message,
                     scala.concurrent.ExecutionContext executor,
                     ActorRef sender)
```
    Schedules a message to be sent repeatedly with an initial delay and frequency. E.g. if you would like a message to be sent immediately and thereafter every 500ms you would set delay=Duration.Zero and interval=Duration(500, TimeUnit.MILLISECONDS)
    Java API
    
    Parameters:
    
    initialDelay - (undocumented)
    
    interval - (undocumented)
    
    receiver - (undocumented)
    
    message - (undocumented)
    
    executor - (undocumented)
    
    sender - (undocumented)
    
    Returns:
    
    (undocumented)
  - schedule
```
Cancellable schedule(scala.concurrent.duration.FiniteDuration initialDelay,
                     scala.concurrent.duration.FiniteDuration interval,
                     scala.Function0<scala.runtime.BoxedUnit> f,
                     scala.concurrent.ExecutionContext executor)
```
    Schedules a function to be run repeatedly with an initial delay and a frequency. E.g. if you would like the function to be run after 2 seconds and thereafter every 100ms you would set delay = Duration(2, TimeUnit.SECONDS) and interval = Duration(100, TimeUnit.MILLISECONDS). If the execution of the function takes longer than the interval, the subsequent execution will start immediately after the prior one completes (there will be no overlap of the function executions). In such cases, the actual execution interval will differ from the interval passed to this method.
    If the function throws an exception the repeated scheduling is aborted, i.e. the function will not be invoked any more.
    Scala API
    
    Parameters:
    
    initialDelay - (undocumented)
    
    interval - (undocumented)
    
    f - (undocumented)
    
    executor - (undocumented)
    
    Returns:
    
    (undocumented)
  - schedule
```
Cancellable schedule(scala.concurrent.duration.FiniteDuration initialDelay,
                     scala.concurrent.duration.FiniteDuration interval,
                     java.lang.Runnable runnable,
                     scala.concurrent.ExecutionContext executor)
```
    Schedules a Runnable to be run repeatedly with an initial delay and a frequency. E.g. if you would like the function to be run after 2 seconds and thereafter every 100ms you would set delay = Duration(2, TimeUnit.SECONDS) and interval = Duration(100, TimeUnit.MILLISECONDS). If the execution of the runnable takes longer than the interval, the subsequent execution will start immediately after the prior one completes (there will be no overlap of executions of the runnable). In such cases, the actual execution interval will differ from the interval passed to this method.
    If the Runnable throws an exception the repeated scheduling is aborted, i.e. the function will not be invoked any more.
    
    Parameters:
    
    initialDelay - (undocumented)
    
    interval - (undocumented)
    
    runnable - (undocumented)
    
    executor - (undocumented)
    
    Returns:
    
    (undocumented)
    
    Throws:
    
    java.lang.IllegalArgumentException - if the given delays exceed the maximum reach (calculated as: delay / tickNanos > Int.MaxValue).
    Java API
  - schedule
```
Cancellable schedule(java.time.Duration initialDelay,
                     java.time.Duration interval,
                     java.lang.Runnable runnable,
                     scala.concurrent.ExecutionContext executor)
```
    Schedules a Runnable to be run repeatedly with an initial delay and a frequency. E.g. if you would like the function to be run after 2 seconds and thereafter every 100ms you would set delay = Duration(2, TimeUnit.SECONDS) and interval = Duration(100, TimeUnit.MILLISECONDS). If the execution of the runnable takes longer than the interval, the subsequent execution will start immediately after the prior one completes (there will be no overlap of executions of the runnable). In such cases, the actual execution interval will differ from the interval passed to this method.
    If the Runnable throws an exception the repeated scheduling is aborted, i.e. the function will not be invoked any more.
    
    Parameters:
    
    initialDelay - (undocumented)
    
    interval - (undocumented)
    
    runnable - (undocumented)
    
    executor - (undocumented)
    
    Returns:
    
    (undocumented)
    
    Throws:
    
    java.lang.IllegalArgumentException - if the given delays exceed the maximum reach (calculated as: delay / tickNanos > Int.MaxValue).
    Java API
  - schedule$default$6
```
ActorRef schedule$default$6(scala.concurrent.duration.FiniteDuration initialDelay,
                            scala.concurrent.duration.FiniteDuration interval,
                            ActorRef receiver,
                            java.lang.Object message)
```
  - scheduleOnce
```
Cancellable scheduleOnce(scala.concurrent.duration.FiniteDuration delay,
                         ActorRef receiver,
                         java.lang.Object message,
                         scala.concurrent.ExecutionContext executor,
                         ActorRef sender)
```
    Schedules a message to be sent once with a delay, i.e. a time period that has to pass before the message is sent.
    
    Parameters:
    
    delay - (undocumented)
    
    receiver - (undocumented)
    
    message - (undocumented)
    
    executor - (undocumented)
    
    sender - (undocumented)
    
    Returns:
    
    (undocumented)
    
    Throws:
    
    java.lang.IllegalArgumentException - if the given delays exceed the maximum reach (calculated as: delay / tickNanos > Int.MaxValue).
    Java & Scala API
  - scheduleOnce
```
Cancellable scheduleOnce(java.time.Duration delay,
                         ActorRef receiver,
                         java.lang.Object message,
                         scala.concurrent.ExecutionContext executor,
                         ActorRef sender)
```
    Schedules a message to be sent once with a delay, i.e. a time period that has to pass before the message is sent.
    
    Parameters:
    
    delay - (undocumented)
    
    receiver - (undocumented)
    
    message - (undocumented)
    
    executor - (undocumented)
    
    sender - (undocumented)
    
    Returns:
    
    (undocumented)
    
    Throws:
    
    java.lang.IllegalArgumentException - if the given delays exceed the maximum reach (calculated as: delay / tickNanos > Int.MaxValue).
    Java API
  - scheduleOnce
```
Cancellable scheduleOnce(scala.concurrent.duration.FiniteDuration delay,
                         scala.Function0<scala.runtime.BoxedUnit> f,
                         scala.concurrent.ExecutionContext executor)
```
    Schedules a function to be run once with a delay, i.e. a time period that has to pass before the function is run.
    
    Parameters:
    
    delay - (undocumented)
    
    f - (undocumented)
    
    executor - (undocumented)
    
    Returns:
    
    (undocumented)
    
    Throws:
    
    java.lang.IllegalArgumentException - if the given delays exceed the maximum reach (calculated as: delay / tickNanos > Int.MaxValue).
    Scala API
  - scheduleOnce
```
Cancellable scheduleOnce(scala.concurrent.duration.FiniteDuration delay,
                         java.lang.Runnable runnable,
                         scala.concurrent.ExecutionContext executor)
```
    Schedules a Runnable to be run once with a delay, i.e. a time period that has to pass before the runnable is executed.
    
    Parameters:
    
    delay - (undocumented)
    
    runnable - (undocumented)
    
    executor - (undocumented)
    
    Returns:
    
    (undocumented)
    
    Throws:
    
    java.lang.IllegalArgumentException - if the given delays exceed the maximum reach (calculated as: delay / tickNanos > Int.MaxValue).
    Java & Scala API
  - scheduleOnce
```
Cancellable scheduleOnce(java.time.Duration delay,
                         java.lang.Runnable runnable,
                         scala.concurrent.ExecutionContext executor)
```
    Schedules a Runnable to be run once with a delay, i.e. a time period that has to pass before the runnable is executed.
    
    Parameters:
    
    delay - (undocumented)
    
    runnable - (undocumented)
    
    executor - (undocumented)
    
    Returns:
    
    (undocumented)
    
    Throws:
    
    java.lang.IllegalArgumentException - if the given delays exceed the maximum reach (calculated as: delay / tickNanos > Int.MaxValue).
    Java & Scala API
  - scheduleOnce$default$5
```
ActorRef scheduleOnce$default$5(scala.concurrent.duration.FiniteDuration delay,
                                ActorRef receiver,
                                java.lang.Object message)
```

Interface Scheduler

Method Summary

Method Detail

maxFrequency

schedule

schedule

schedule

schedule

schedule

schedule$default$6

scheduleOnce

scheduleOnce

scheduleOnce

scheduleOnce

scheduleOnce

scheduleOnce$default$5