com.lucidworks.apollo.component

Class ExecutorComponent

java.lang.Object

com.lucidworks.apollo.component.ExecutorComponent

All Implemented Interfaces:

java.io.Closeable, java.lang.AutoCloseable

public class ExecutorComponent
extends java.lang.Object
implements java.io.Closeable

A convenience class for creating executor services. It handles the boilerplate of custom thread names (great for stack traces!) and registering the executor services centrally so that they can be shut down appropriately. Provides a potential point for instrumentation, too, should we want to.

Every method in this class returns a com.google.common.util.concurrent.ListeningExecutorService, so that you can listen for task completion if you would like.

If you're looking for scheduled thread pools, use ScheduledRunnableComponent instead. It handles more of that for you.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	ExecutorComponent.AbortPolicy Just like the java.util.concurrent.ThreadPoolExecutor.AbortPolicy, but with a better error message.
class	ExecutorComponent.ListeningExecutorServiceBuilder

Constructor Summary

Constructors

Constructor and Description
ExecutorComponent(MetricRegistry metricRegistry)

Method Summary

Modifier and Type	Method and Description
void	close()
ListeningExecutorService	getOrCreateCachedThreadPool(java.lang.String threadNameFormat)
ListeningExecutorService	getOrCreateSingleThreadExecutor(java.lang.String threadPoolName, java.lang.String threadNameFormat) TODO: experimental.
ExecutorComponent.ListeningExecutorServiceBuilder	newBuilder()
ListeningExecutorService	newCachedThreadPool(java.lang.String threadNameFormat) Creates a thread pool that creates new threads as needed, but will reuse previously constructed threads when they are available.
ListeningExecutorService	newFixedThreadPool(int nThreads, java.lang.String threadNameFormat) Creates a thread pool that reuses a fixed number of threads operating off a shared unbounded queue, using the provided ThreadFactory to create new threads when needed.
ListeningExecutorService	newSingleThreadExecutor(java.lang.String threadNameFormat)

Methods inherited from class java.lang.Object

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

Constructor Detail

ExecutorComponent

public ExecutorComponent(MetricRegistry metricRegistry)

Method Detail

getOrCreateSingleThreadExecutor

public ListeningExecutorService getOrCreateSingleThreadExecutor(java.lang.String threadPoolName,
                                                                java.lang.String threadNameFormat)

TODO: experimental. Not sure if we want this kind of interface. If you want to reuse a thread pool between multiple components, you can use this.

Parameters:

threadPoolName - the name of the thread pool to get. Multiple requests with the same thread pool name will return the same thread pool.

threadNameFormat - a String.format(String, Object...)-compatible format String, to which a unique integer (0, 1, etc.) will be supplied as the single parameter. This integer will be unique to the built instance of the ThreadFactory and will be assigned sequentially. For example, "rpc-pool-%d" will generate thread names like "rpc-pool-0", "rpc-pool-1", "rpc-pool-2", etc.

Returns:

newSingleThreadExecutor

public ListeningExecutorService newSingleThreadExecutor(java.lang.String threadNameFormat)

Parameters:

threadNameFormat - a String.format(String, Object...)-compatible format String, to which a unique integer (0, 1, etc.) will be supplied as the single parameter. This integer will be unique to the built instance of the ThreadFactory and will be assigned sequentially. For example, "rpc-pool-%d" will generate thread names like "rpc-pool-0", "rpc-pool-1", "rpc-pool-2", etc.

Returns:

the newly created thread pool

newFixedThreadPool

public ListeningExecutorService newFixedThreadPool(int nThreads,
                                                   java.lang.String threadNameFormat)

Creates a thread pool that reuses a fixed number of threads operating off a shared unbounded queue, using the provided ThreadFactory to create new threads when needed. At any point, at most nThreads threads will be active processing tasks. If additional tasks are submitted when all threads are active, they will wait in the queue until a thread is available. If any thread terminates due to a failure during execution prior to shutdown, a new one will take its place if needed to execute subsequent tasks. The threads in the pool will exist until it is explicitly shutdown.

Parameters:

nThreads - the number of threads in the pool

threadNameFormat - a String.format(String, Object...)-compatible format String, to which a unique integer (0, 1, etc.) will be supplied as the single parameter. This integer will be unique to the built instance of the ThreadFactory and will be assigned sequentially. For example, "rpc-pool-%d" will generate thread names like "rpc-pool-0", "rpc-pool-1", "rpc-pool-2", etc.

Returns:

the newly created thread pool

newCachedThreadPool

public ListeningExecutorService newCachedThreadPool(java.lang.String threadNameFormat)

Creates a thread pool that creates new threads as needed, but will reuse previously constructed threads when they are available. These pools will typically improve the performance of programs that execute many short-lived asynchronous tasks. 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. Threads that have not been used for sixty seconds are terminated and removed from the cache. Thus, a pool that remains idle for long enough will not consume any resources. Note that pools with similar properties but different details (for example, timeout parameters) may be created using ThreadPoolExecutor constructors. Note that unlike java.util.concurrent.Executors#newCachedThreadPool, this implementation does limit the pool size to 15,000 threads, since that is a practical limit on a Linux machine with ~16gb of RAM. That is based on the assumptions that: 1.) if you hit that limit, something is going wrong in your system, and 2.) it's at least marginally better to fail at the point of execution with a RejectedExecutionException versus an OutOfMemoryError with a "could not create new native thread" message. Both are probably terminal, but at least the former may be slightly more understandable?

Parameters:

threadNameFormat - a String.format(String, Object...)-compatible format String, to which a unique integer (0, 1, etc.) will be supplied as the single parameter. This integer will be unique to the built instance of the ThreadFactory and will be assigned sequentially. For example, "rpc-pool-%d" will generate thread names like "rpc-pool-0", "rpc-pool-1", "rpc-pool-2", etc.

Returns:

the newly created thread pool

getOrCreateCachedThreadPool

public ListeningExecutorService getOrCreateCachedThreadPool(java.lang.String threadNameFormat)

newBuilder

public ExecutorComponent.ListeningExecutorServiceBuilder newBuilder()

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