public abstract class AbstractThreadPool extends AbstractExecutorService implements Thread.UncaughtExceptionHandler, MonitoringAware<ThreadPoolProbe>
ExecutorService
implementation.Modifier and Type | Class and Description |
---|---|
class |
AbstractThreadPool.Worker |
Modifier and Type | Field and Description |
---|---|
protected ThreadPoolConfig |
config |
static int |
DEFAULT_IDLE_THREAD_KEEPALIVE_TIMEOUT |
static int |
DEFAULT_MAX_TASKS_QUEUED |
static int |
DEFAULT_MAX_THREAD_COUNT |
static int |
DEFAULT_MIN_THREAD_COUNT |
protected DelayedExecutor.DelayQueue<AbstractThreadPool.Worker> |
delayedQueue |
protected DefaultMonitoringConfig<ThreadPoolProbe> |
monitoringConfig
ThreadPool probes
|
protected static Runnable |
poison |
protected boolean |
running |
protected Object |
stateLock |
protected long |
transactionTimeoutMillis |
protected Map<AbstractThreadPool.Worker,Long> |
workers |
Constructor and Description |
---|
AbstractThreadPool(ThreadPoolConfig config) |
Modifier and Type | Method and Description |
---|---|
protected void |
afterExecute(AbstractThreadPool.Worker worker,
Thread thread,
Runnable r,
Throwable t)
Method invoked upon completion of execution of the given Runnable.
|
boolean |
awaitTermination(long timeout,
TimeUnit unit) |
protected void |
beforeExecute(AbstractThreadPool.Worker worker,
Thread t,
Runnable r)
Method invoked prior to executing the given Runnable in the
given thread.
|
protected static void |
drain(Queue<Runnable> from,
Collection<Runnable> to) |
ThreadPoolConfig |
getConfig() |
protected ThreadFactory |
getDefaultThreadFactory() |
MonitoringConfig<ThreadPoolProbe> |
getMonitoringConfig()
Return the object associated
MonitoringConfig . |
Queue<Runnable> |
getQueue() |
boolean |
isShutdown() |
boolean |
isTerminated() |
protected void |
onMaxNumberOfThreadsReached()
Method is called by AbstractThreadPool, when maximum number of
worker threads is reached and task will need to wait in task queue, until
one of the threads will be able to process it.
|
protected void |
onTaskCompletedEvent(Runnable task)
This method will be invoked when a the specified
Runnable has
completed execution. |
protected void |
onTaskDequeued(Runnable task)
Method is called by a thread pool each time a task has been dequeued from
a task queue.
|
protected void |
onTaskQueued(Runnable task)
Method is called by a thread pool each time new task has been queued to
a task queue.
|
protected void |
onTaskQueueOverflow()
Method is called by a thread pool, when new task could not be added
to a task queue, because task queue is full.
|
protected void |
onWorkerExit(AbstractThreadPool.Worker worker)
Method is called by
AbstractThreadPool.Worker , when it's completing
AbstractThreadPool.Worker.run() method execution, which in most cases means,
that ThreadPool's thread will be released. |
protected void |
onWorkerStarted(AbstractThreadPool.Worker worker)
Method is called by
AbstractThreadPool.Worker , when it's starting
AbstractThreadPool.Worker.run() method execution, which means, that ThreadPool's
thread is getting active and ready to process tasks. |
protected void |
poisonAll() |
void |
shutdown() |
List<Runnable> |
shutdownNow() |
protected void |
startWorker(AbstractThreadPool.Worker worker)
must hold statelock while calling this method.
|
String |
toString() |
void |
uncaughtException(Thread thread,
Throwable throwable) |
protected void |
validateNewPoolSize(int corePoolsize,
int maxPoolSize) |
invokeAll, invokeAll, invokeAny, invokeAny, newTaskFor, newTaskFor, submit, submit, submit
public static final int DEFAULT_MIN_THREAD_COUNT
public static final int DEFAULT_MAX_THREAD_COUNT
public static final int DEFAULT_MAX_TASKS_QUEUED
public static final int DEFAULT_IDLE_THREAD_KEEPALIVE_TIMEOUT
protected static final Runnable poison
protected final Object stateLock
protected final Map<AbstractThreadPool.Worker,Long> workers
protected volatile boolean running
protected final ThreadPoolConfig config
protected final long transactionTimeoutMillis
protected final DelayedExecutor.DelayQueue<AbstractThreadPool.Worker> delayedQueue
protected final DefaultMonitoringConfig<ThreadPoolProbe> monitoringConfig
public AbstractThreadPool(ThreadPoolConfig config)
protected void startWorker(AbstractThreadPool.Worker worker)
worker
- public ThreadPoolConfig getConfig()
public List<Runnable> shutdownNow()
shutdownNow
in interface ExecutorService
public void shutdown()
shutdown
in interface ExecutorService
public boolean isShutdown()
isShutdown
in interface ExecutorService
public boolean isTerminated()
isTerminated
in interface ExecutorService
public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException
awaitTermination
in interface ExecutorService
InterruptedException
protected void poisonAll()
protected static void drain(Queue<Runnable> from, Collection<Runnable> to)
protected void validateNewPoolSize(int corePoolsize, int maxPoolSize)
protected void beforeExecute(AbstractThreadPool.Worker worker, Thread t, Runnable r)
This implementation does nothing, but may be customized in subclasses. Note: To properly nest multiple overridings, subclasses should generally invoke super.beforeExecute at the end of this method.
worker
- the AbstractThreadPool.Worker
, running the the thread tt
- the thread that will run task r.r
- the task that will be executed.protected void afterExecute(AbstractThreadPool.Worker worker, Thread thread, Runnable r, Throwable t)
Note: When actions are enclosed in tasks (such as
FutureTask
) either explicitly or via methods such as
submit, these task objects catch and maintain
computational exceptions, and so they do not cause abrupt
termination, and the internal exceptions are not
passed to this method.
This implementation does nothing, but may be customized in subclasses. Note: To properly nest multiple overridings, subclasses should generally invoke super.afterExecute at the beginning of this method.
worker
- the AbstractThreadPool.Worker
, running the the thread tthread
- r
- the runnable that has completed.t
- the exception that caused termination, or null if
execution completed normally.protected void onTaskCompletedEvent(Runnable task)
This method will be invoked when a the specified Runnable
has
completed execution.
task
- the unit of work that has completed processingprotected void onWorkerStarted(AbstractThreadPool.Worker worker)
AbstractThreadPool.Worker
, when it's starting
AbstractThreadPool.Worker.run()
method execution, which means, that ThreadPool's
thread is getting active and ready to process tasks.
This method is called from AbstractThreadPool.Worker
's thread.worker
- protected void onWorkerExit(AbstractThreadPool.Worker worker)
AbstractThreadPool.Worker
, when it's completing
AbstractThreadPool.Worker.run()
method execution, which in most cases means,
that ThreadPool's thread will be released. This method is called from
AbstractThreadPool.Worker
's thread.worker
- protected void onMaxNumberOfThreadsReached()
protected void onTaskQueued(Runnable task)
task
- protected void onTaskDequeued(Runnable task)
task
- protected void onTaskQueueOverflow()
RejectedExecutionException
public MonitoringConfig<ThreadPoolProbe> getMonitoringConfig()
MonitoringConfig
.getMonitoringConfig
in interface MonitoringAware<ThreadPoolProbe>
MonitoringConfig
.public void uncaughtException(Thread thread, Throwable throwable)
uncaughtException
in interface Thread.UncaughtExceptionHandler
protected final ThreadFactory getDefaultThreadFactory()
Copyright © 2014 Oracle Corporation. All rights reserved.