Class ThreadPool

  • All Implemented Interfaces:
    java.io.Closeable, java.lang.AutoCloseable, Scheduler

    public class ThreadPool
    extends java.lang.Object
    implements Scheduler, java.io.Closeable
    • Field Detail

      • ESTIMATED_TIME_INTERVAL_SETTING

        public static Setting<TimeValue> ESTIMATED_TIME_INTERVAL_SETTING
    • Method Detail

      • relativeTimeInMillis

        public long relativeTimeInMillis()
        Returns a value of milliseconds that may be used for relative time calculations. This method should only be used for calculating time deltas. For an epoch based timestamp, see absoluteTimeInMillis().
      • absoluteTimeInMillis

        public long absoluteTimeInMillis()
        Returns the value of milliseconds since UNIX epoch. This method should only be used for exact date/time formatting. For calculating time deltas that should not suffer from negative deltas, which are possible with this method, see relativeTimeInMillis().
      • estimatedTimeInMillisCounter

        public org.apache.lucene.util.Counter estimatedTimeInMillisCounter()
      • generic

        public java.util.concurrent.ExecutorService generic()
        Get the generic ExecutorService. This executor service Executor.execute(Runnable) method will run the Runnable it is given in the ThreadContext of the thread that queues it.

        Warning: this ExecutorService will not throw RejectedExecutionException if you submit a task while it shutdown. It will instead silently queue it and not run it.

      • executor

        public java.util.concurrent.ExecutorService executor​(java.lang.String name)
        Get the ExecutorService with the given name. This executor service's Executor.execute(Runnable) method will run the Runnable it is given in the ThreadContext of the thread that queues it.

        Warning: this ExecutorService might not throw RejectedExecutionException if you submit a task while it shutdown. It will instead silently queue it and not run it.

        Parameters:
        name - the name of the executor service to obtain
        Throws:
        java.lang.IllegalArgumentException - if no executor service with the specified name exists
      • schedule

        public Scheduler.ScheduledCancellable schedule​(java.lang.Runnable command,
                                                       TimeValue delay,
                                                       java.lang.String executor)
        Schedules a one-shot command to run after a given delay. The command is not run in the context of the calling thread. To preserve the context of the calling thread you may call threadPool.getThreadContext().preserveContext on the runnable before passing it to this method.
        Specified by:
        schedule in interface Scheduler
        Parameters:
        command - the command to run
        delay - delay before the task executes
        executor - the name of the thread pool on which to execute this task. SAME means "execute on the scheduler thread" which changes the meaning of the ScheduledFuture returned by this method. In that case the ScheduledFuture will complete only when the command completes.
        Returns:
        a ScheduledFuture who's get will return when the task is has been added to its target thread pool and throw 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 will cannot interact with it.
        Throws:
        EsRejectedExecutionException - if the task cannot be scheduled for execution
      • scheduleDeprecated

        @Deprecated
        public java.util.concurrent.ScheduledFuture<?> scheduleDeprecated​(TimeValue delay,
                                                                          java.lang.String executor,
                                                                          java.lang.Runnable command)
        Deprecated.
        Only in 6.7, to be used in the one case where the old style schedule is necessary to stay API backwards compatible.
      • scheduleWithFixedDelay

        public Scheduler.Cancellable scheduleWithFixedDelay​(java.lang.Runnable command,
                                                            TimeValue interval,
                                                            java.lang.String executor)
        Description copied from interface: Scheduler
        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.
        Specified by:
        scheduleWithFixedDelay in interface Scheduler
        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.
      • preserveContext

        public java.lang.Runnable preserveContext​(java.lang.Runnable command)
        Description copied from interface: Scheduler
        Does nothing by default but can be used by subclasses to save the current thread context and wraps the command in a Runnable that restores that context before running the command.
        Specified by:
        preserveContext in interface Scheduler
      • stopCachedTimeThread

        protected final void stopCachedTimeThread()
      • shutdown

        public void shutdown()
      • shutdownNow

        public void shutdownNow()
      • awaitTermination

        public boolean awaitTermination​(long timeout,
                                        java.util.concurrent.TimeUnit unit)
                                 throws java.lang.InterruptedException
        Throws:
        java.lang.InterruptedException
      • scheduler

        public java.util.concurrent.ScheduledExecutorService scheduler()
      • searchThreadPoolSize

        public static int searchThreadPoolSize​(int availableProcessors)
      • terminate

        public static boolean terminate​(java.util.concurrent.ExecutorService service,
                                        long timeout,
                                        java.util.concurrent.TimeUnit timeUnit)
        Returns true if the given service was terminated successfully. If the termination timed out, the service is null this method will return false.
      • terminate

        public static boolean terminate​(ThreadPool pool,
                                        long timeout,
                                        java.util.concurrent.TimeUnit timeUnit)
        Returns true if the given pool was terminated successfully. If the termination timed out, the service is null this method will return false.
      • close

        public void close()
                   throws java.io.IOException
        Specified by:
        close in interface java.lang.AutoCloseable
        Specified by:
        close in interface java.io.Closeable
        Throws:
        java.io.IOException
      • assertNotScheduleThread

        public static boolean assertNotScheduleThread​(java.lang.String reason)