org.elasticsearch.threadpool

Class ThreadPool

java.lang.Object

org.elasticsearch.common.component.AbstractComponent

org.elasticsearch.threadpool.ThreadPool

All Implemented Interfaces:

java.io.Closeable, java.lang.AutoCloseable, Scheduler

public class ThreadPool
extends AbstractComponent
implements Scheduler, java.io.Closeable

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	ThreadPool.Info
static class	ThreadPool.Names
static class	ThreadPool.ThreadPoolType

Nested classes/interfaces inherited from interface org.elasticsearch.threadpool.Scheduler

Scheduler.Cancellable, Scheduler.ReschedulingRunnable

Field Summary

Fields

Modifier and Type	Field and Description
static Setting<TimeValue>	ESTIMATED_TIME_INTERVAL_SETTING
static java.util.Map<java.lang.String,ThreadPool.ThreadPoolType>	THREAD_POOL_TYPES

Fields inherited from class org.elasticsearch.common.component.AbstractComponent

deprecationLogger, logger, settings

Constructor Summary

Constructors

Constructor and Description
ThreadPool(Settings settings, ExecutorBuilder<?>... customBuilders)

Method Summary

Modifier and Type	Method and Description
long	absoluteTimeInMillis() Returns the value of milliseconds since UNIX epoch.
static boolean	assertNotScheduleThread(java.lang.String reason)
boolean	awaitTermination(long timeout, java.util.concurrent.TimeUnit unit)
java.util.Collection<ExecutorBuilder>	builders()
void	close()
org.apache.lucene.util.Counter	estimatedTimeInMillisCounter()
java.util.concurrent.ExecutorService	executor(java.lang.String name) Get the ExecutorService with the given name.
java.util.concurrent.ExecutorService	generic() Get the generic ExecutorService.
ThreadContext	getThreadContext()
ThreadPoolInfo	info()
ThreadPool.Info	info(java.lang.String name)
java.lang.Runnable	preserveContext(java.lang.Runnable command) 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.
long	relativeTimeInMillis() Returns a value of milliseconds that may be used for relative time calculations.
java.util.concurrent.ScheduledFuture<?>	schedule(TimeValue delay, java.lang.String executor, java.lang.Runnable command) Schedules a one-shot command to run after a given delay.
java.util.concurrent.ScheduledExecutorService	scheduler()
Scheduler.Cancellable	scheduleWithFixedDelay(java.lang.Runnable command, TimeValue interval, java.lang.String executor) Schedules a periodic action that runs on scheduler thread.
static int	searchThreadPoolSize(int availableProcessors)
void	shutdown()
void	shutdownNow()
ThreadPoolStats	stats()
static boolean	terminate(java.util.concurrent.ExecutorService service, long timeout, java.util.concurrent.TimeUnit timeUnit) Returns true if the given service was terminated successfully.
static boolean	terminate(ThreadPool pool, long timeout, java.util.concurrent.TimeUnit timeUnit) Returns true if the given pool was terminated successfully.

Methods inherited from class org.elasticsearch.common.component.AbstractComponent

logDeprecatedSetting, logRemovedSetting, nodeName

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.elasticsearch.threadpool.Scheduler

awaitTermination, initScheduler, terminate

Field Detail

THREAD_POOL_TYPES

public static final java.util.Map<java.lang.String,ThreadPool.ThreadPoolType> THREAD_POOL_TYPES

ESTIMATED_TIME_INTERVAL_SETTING

public static Setting<TimeValue> ESTIMATED_TIME_INTERVAL_SETTING

Constructor Detail

ThreadPool

public ThreadPool(Settings settings,
                  ExecutorBuilder<?>... customBuilders)

Method Detail

builders

public java.util.Collection<ExecutorBuilder> builders()

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()

info

public ThreadPoolInfo info()

info

public ThreadPool.Info info(java.lang.String name)

stats

public ThreadPoolStats stats()

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 java.util.concurrent.ScheduledFuture<?> schedule(TimeValue delay,
                                                        java.lang.String executor,
                                                        java.lang.Runnable command)

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:

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.

command - the command to run

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

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

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.io.Closeable

Specified by:

close in interface java.lang.AutoCloseable

Throws:

java.io.IOException

getThreadContext

public ThreadContext getThreadContext()

assertNotScheduleThread

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