Package akka.actor

Class AbstractScheduler

  • All Implemented Interfaces:
    Scheduler

    public abstract class AbstractScheduler
    extends AbstractSchedulerBase
    An Akka scheduler service. This one needs one special behavior: if Closeable, it MUST execute all outstanding tasks upon .close() in order to properly shutdown all dispatchers.

    Furthermore, this timer service MUST throw IllegalStateException if it cannot schedule a task. Once scheduled, the task MUST be executed. If executed upon close(), the task may execute before its timeout.

    Scheduler implementation are loaded reflectively at ActorSystem start-up with the following constructor arguments: 1) the system’s com.typesafe.config.Config (from system.settings.config) 2) a akka.event.LoggingAdapter 3) a java.util.concurrent.ThreadFactory

    • Constructor Detail

      • AbstractScheduler

        public AbstractScheduler()
    • Method Detail

      • schedule

        public abstract Cancellable schedule​(scala.concurrent.duration.FiniteDuration initialDelay,
                                             scala.concurrent.duration.FiniteDuration interval,
                                             java.lang.Runnable runnable,
                                             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)
        Parameters:
        initialDelay - (undocumented)
        interval - (undocumented)
        runnable - (undocumented)
        executor - (undocumented)
        Returns:
        (undocumented)
      • schedule

        public Cancellable schedule​(java.time.Duration initialDelay,
                                    java.time.Duration interval,
                                    java.lang.Runnable runnable,
                                    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.ofMillis(100)
        Parameters:
        initialDelay - (undocumented)
        interval - (undocumented)
        runnable - (undocumented)
        executor - (undocumented)
        Returns:
        (undocumented)
      • scheduleOnce

        public abstract 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)
      • scheduleOnce

        public 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)
      • maxFrequency

        public abstract 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)