org.elasticsearch.common.util.concurrent
Class DynamicExecutors

java.lang.Object
  org.elasticsearch.common.util.concurrent.DynamicExecutors

public class DynamicExecutors
extends java.lang.Object

Constructor Summary

DynamicExecutors()

Method Summary

static java.util.concurrent.ExecutorService	newBlockingThreadPool(int min, int max, long keepAliveTime, int capacity, long waitTime) Creates a thread pool similar to that constructed by newScalingThreadPool(int, int, long), but blocks the call to execute if the queue has reached it's capacity, and all max threads are busy handling requests.
static java.util.concurrent.ExecutorService	newBlockingThreadPool(int min, int max, long keepAliveTime, int capacity, long waitTime, java.util.concurrent.ThreadFactory threadFactory) Creates a thread pool, same as in newBlockingThreadPool(int, int, long, int, long), using the provided ThreadFactory to create new threads when needed.
static java.util.concurrent.ExecutorService	newScalingThreadPool(int min, int max, long keepAliveTime) Creates a thread pool that creates new threads as needed, but will reuse previously constructed threads when they are available.
static java.util.concurrent.ExecutorService	newScalingThreadPool(int min, int max, long keepAliveTime, java.util.concurrent.ThreadFactory threadFactory) Creates a thread pool, same as in newScalingThreadPool(int, int, long), using the provided ThreadFactory to create new threads when needed.

Methods inherited from class java.lang.Object

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

Constructor Detail

DynamicExecutors

public DynamicExecutors()

Method Detail

newScalingThreadPool

public static java.util.concurrent.ExecutorService newScalingThreadPool(int min,
                                                                        int max,
                                                                        long keepAliveTime)

Creates a thread pool that creates new threads as needed, but will reuse previously constructed threads when they are available. Calls to execute will reuse previously constructed threads if available. If no existing thread is available, a new thread will be created and added to the pool. No more than max threads will be created. Threads that have not been used for a keepAlive timeout are terminated and removed from the cache. Thus, a pool that remains idle for long enough will not consume any resources other than the min specified.

Parameters:

min - the number of threads to keep in the pool, even if they are idle.

max - the maximum number of threads to allow in the pool.

keepAliveTime - when the number of threads is greater than the min, this is the maximum time that excess idle threads will wait for new tasks before terminating (in milliseconds).

Returns:

the newly created thread pool

newScalingThreadPool

public static java.util.concurrent.ExecutorService newScalingThreadPool(int min,
                                                                        int max,
                                                                        long keepAliveTime,
                                                                        java.util.concurrent.ThreadFactory threadFactory)

Creates a thread pool, same as in newScalingThreadPool(int, int, long), using the provided ThreadFactory to create new threads when needed.

Parameters:

min - the number of threads to keep in the pool, even if they are idle.

max - the maximum number of threads to allow in the pool.

keepAliveTime - when the number of threads is greater than the min, this is the maximum time that excess idle threads will wait for new tasks before terminating (in milliseconds).

threadFactory - the factory to use when creating new threads.

Returns:

the newly created thread pool

newBlockingThreadPool

public static java.util.concurrent.ExecutorService newBlockingThreadPool(int min,
                                                                         int max,
                                                                         long keepAliveTime,
                                                                         int capacity,
                                                                         long waitTime)

Creates a thread pool similar to that constructed by newScalingThreadPool(int, int, long), but blocks the call to execute if the queue has reached it's capacity, and all max threads are busy handling requests.

If the wait time of this queue has elapsed, a RejectedExecutionException will be thrown.

Parameters:

min - the number of threads to keep in the pool, even if they are idle.

max - the maximum number of threads to allow in the pool.

keepAliveTime - when the number of threads is greater than the min, this is the maximum time that excess idle threads will wait for new tasks before terminating (in milliseconds).

capacity - the fixed capacity of the underlying queue (resembles backlog).

waitTime - the wait time (in milliseconds) for space to become available in the queue.

Returns:

the newly created thread pool

newBlockingThreadPool

public static java.util.concurrent.ExecutorService newBlockingThreadPool(int min,
                                                                         int max,
                                                                         long keepAliveTime,
                                                                         int capacity,
                                                                         long waitTime,
                                                                         java.util.concurrent.ThreadFactory threadFactory)

Creates a thread pool, same as in newBlockingThreadPool(int, int, long, int, long), using the provided ThreadFactory to create new threads when needed.

Parameters:

min - the number of threads to keep in the pool, even if they are idle.

max - the maximum number of threads to allow in the pool.

keepAliveTime - when the number of threads is greater than the min, this is the maximum time that excess idle threads will wait for new tasks before terminating (in milliseconds).

capacity - the fixed capacity of the underlying queue (resembles backlog).

waitTime - the wait time (in milliseconds) for space to become available in the queue.

threadFactory - the factory to use when creating new threads.

Returns:

the newly created thread pool