Package org.elasticsearch.threadpool

Interface Scheduler

All Known Implementing Classes:
ThreadPool
public interface Scheduler
Scheduler that allows to schedule one-shot and periodic commands.

  • Nested Class Summary

    Nested Classes
    Modifier and Type
    Interface
    Description
    static interface 
    Scheduler.Cancellable
    This interface represents an object whose execution may be cancelled during runtime.
    static class 
    Scheduler.ReschedulingRunnable
    This class encapsulates the scheduling of a that needs to be repeated on a interval.
    static class 
    Scheduler.SafeScheduledThreadPoolExecutor
    This subclass ensures to properly bubble up Throwable instances of both type Error and Exception thrown in submitted/scheduled tasks to the uncaught exception handler
    static interface 
    Scheduler.ScheduledCancellable
    A scheduled cancellable allow cancelling and reading the remaining delay of a scheduled task.

  • Method Summary

    Modifier and Type
    Method
    Description
    static boolean
     scheduledThreadPoolExecutor, long timeout,  timeUnit)
     
    static
    initScheduler​(Settings settings,  schedulerName)
    Create a scheduler that can be used client side.
    Scheduler.ScheduledCancellable
     command, org.elasticsearch.core.TimeValue delay,  executor)
    Schedules a one-shot command to be run after a given delay.
    default Scheduler.Cancellable
     command, org.elasticsearch.core.TimeValue interval,  executor)
    Schedules a periodic action that runs on scheduler thread.
    static boolean
     scheduledThreadPoolExecutor, long timeout,  timeUnit)
     
    static Scheduler.Cancellable
    <?> future)
    Utility method to wrap a Future as a Cancellable
    static Scheduler.ScheduledCancellable
    <?> scheduledFuture)
    Utility method to wrap a ScheduledFuture as a ScheduledCancellable

  • Method Details

    • initScheduler

      static  initScheduler​(Settings settings,  schedulerName)
      Create a scheduler that can be used client side. Server side, please use ThreadPool.schedule instead. Notice that if any scheduled jobs fail with an exception, these will bubble up to the uncaught exception handler where they will be logged as a warning. This includes jobs started using execute, submit and schedule.
      Parameters:
      settings - the settings to use
      schedulerName - a string that identifies the threads belonging to this scheduler
      Returns:
      executor

    • terminate

      static boolean terminate​( scheduledThreadPoolExecutor, long timeout,  timeUnit)

    • awaitTermination

      static boolean awaitTermination​( scheduledThreadPoolExecutor, long timeout,  timeUnit)

    • schedule

       command, org.elasticsearch.core.TimeValue delay,  executor)
      Schedules a one-shot command to be run after a given delay. The command is run in the context of the calling thread. The command runs on scheduler thread. Do not run blocking calls on the scheduler thread. Subclasses may allow to execute on a different executor, in which case blocking calls are allowed.
      Parameters:
      command - the command to run
      delay - delay before the task executes
      executor - the name of the executor that has to execute this task. Ignored in the default implementation but can be used by subclasses that support multiple executors.
      Returns:
      a ScheduledFuture who's get will return when the task has been added to its target thread pool and throws an exception if the task is canceled before it was added to its target thread pool. Once the task has been added to its target thread pool the ScheduledFuture cannot interact with it.
      Throws:
      EsRejectedExecutionException - if the task cannot be scheduled for execution

    • scheduleWithFixedDelay

      default  command, org.elasticsearch.core.TimeValue interval,  executor)
      Schedules a periodic action that runs on scheduler thread. Do not run blocking calls on the scheduler thread. Subclasses may allow to execute on a different executor, in which case blocking calls are allowed.
      Parameters:
      command - the action to take
      interval - the delay interval
      executor - the name of the executor that has to execute this task. Ignored in the default implementation but can be used by subclasses that support multiple executors.
      Returns:
      a Scheduler.Cancellable that can be used to cancel the subsequent runs of the command. If the command is running, it will not be interrupted.

    • wrapAsCancellable

      static <?> future)
      Utility method to wrap a Future as a Cancellable
      Parameters:
      future - the future to wrap
      Returns:
      a cancellable delegating to the future

    • wrapAsScheduledCancellable

      static <?> scheduledFuture)
      Utility method to wrap a ScheduledFuture as a ScheduledCancellable
      Parameters:
      scheduledFuture - the scheduled future to wrap
      Returns:
      a SchedulecCancellable delegating to the scheduledFuture