java.lang.Object
- java.util.concurrent.AbstractExecutorService
- - org.glassfish.grizzly.threadpool.AbstractThreadPool

All Implemented Interfaces:

java.lang.Thread.UncaughtExceptionHandler, java.util.concurrent.Executor, java.util.concurrent.ExecutorService, MonitoringAware<ThreadPoolProbe>

Direct Known Subclasses:

FixedThreadPool, SyncThreadPool
```
public abstract class AbstractThreadPool
extends java.util.concurrent.AbstractExecutorService
implements java.lang.Thread.UncaughtExceptionHandler, MonitoringAware<ThreadPoolProbe>
```
Abstract ExecutorService implementation.

Author:

Alexey Stashok

Nested Class Summary

Nested Classes
Modifier and Type Class Description

class AbstractThreadPool.Worker

Field Summary

Fields
Modifier and Type	Field	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 java.lang.Runnable`	`poison`
`protected boolean`	`running`
`protected java.lang.Object`	`stateLock`
`protected long`	`transactionTimeoutMillis`
`protected java.util.Map<AbstractThreadPool.Worker,java.lang.Long>`	`workers`

Constructor Summary

Constructors
Constructor Description

AbstractThreadPool(ThreadPoolConfig config)

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`protected void`	`afterExecute(AbstractThreadPool.Worker worker, java.lang.Thread thread, java.lang.Runnable r, java.lang.Throwable t)`	Method invoked upon completion of execution of the given Runnable.
`boolean`	`awaitTermination(long timeout, java.util.concurrent.TimeUnit unit)`
`protected void`	`beforeExecute(AbstractThreadPool.Worker worker, java.lang.Thread t, java.lang.Runnable r)`	Method invoked prior to executing the given Runnable in the given thread.
`protected static void`	`drain(java.util.Queue<java.lang.Runnable> from, java.util.Collection<java.lang.Runnable> to)`
`ThreadPoolConfig`	`getConfig()`
`protected java.util.concurrent.ThreadFactory`	`getDefaultThreadFactory()`
`MonitoringConfig<ThreadPoolProbe>`	`getMonitoringConfig()`	Return the object associated `MonitoringConfig`.
`java.util.Queue<java.lang.Runnable>`	`getQueue()`
`int`	`getSize()`
`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`	`onTaskCancelled(java.lang.Runnable task)`	Method is called by a thread pool each time a dequeued task has been canceled instead of being processed.
`protected void`	`onTaskCompletedEvent(java.lang.Runnable task)`	This method will be invoked when a the specified `Runnable` has completed execution.
`protected void`	`onTaskDequeued(java.lang.Runnable task)`	Method is called by a thread pool each time a task has been dequeued from a task queue.
`protected void`	`onTaskQueued(java.lang.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()`
`java.util.List<java.lang.Runnable>`	`shutdownNow()`
`protected void`	`startWorker(AbstractThreadPool.Worker worker)`	must hold statelock while calling this method.
`java.lang.String`	`toString()`
`void`	`uncaughtException(java.lang.Thread thread, java.lang.Throwable throwable)`
`protected void`	`validateNewPoolSize(int corePoolsize, int maxPoolSize)`

Methods inherited from class java.util.concurrent.AbstractExecutorService
invokeAll, invokeAll, invokeAny, invokeAny, newTaskFor, newTaskFor, submit, submit, submit

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.util.concurrent.Executor
execute

- Field Detail
  - DEFAULT_MIN_THREAD_COUNT
```
public static final int DEFAULT_MIN_THREAD_COUNT
```
  - DEFAULT_MAX_THREAD_COUNT
```
public static final int DEFAULT_MAX_THREAD_COUNT
```
  - DEFAULT_MAX_TASKS_QUEUED
```
public static final int DEFAULT_MAX_TASKS_QUEUED
```
    See Also:
    
    Constant Field Values
  - DEFAULT_IDLE_THREAD_KEEPALIVE_TIMEOUT
```
public static final int DEFAULT_IDLE_THREAD_KEEPALIVE_TIMEOUT
```
    See Also:
    
    Constant Field Values
  - poison
```
protected static final java.lang.Runnable poison
```
  - stateLock
```
protected final java.lang.Object stateLock
```
  - workers
```
protected final java.util.Map<AbstractThreadPool.Worker,java.lang.Long> workers
```
  - running
```
protected volatile boolean running
```
  - config
```
protected final ThreadPoolConfig config
```
  - transactionTimeoutMillis
```
protected final long transactionTimeoutMillis
```
  - delayedQueue
```
protected final DelayedExecutor.DelayQueue<AbstractThreadPool.Worker> delayedQueue
```
  - monitoringConfig
```
protected final DefaultMonitoringConfig<ThreadPoolProbe> monitoringConfig
```
    ThreadPool probes
- Constructor Detail
  - AbstractThreadPool
```
public AbstractThreadPool(ThreadPoolConfig config)
```
- Method Detail
  - startWorker
```
protected void startWorker(AbstractThreadPool.Worker worker)
```
    must hold statelock while calling this method.
    
    Parameters:
    
    worker -
  - getConfig
```
public ThreadPoolConfig getConfig()
```
    Returns:
    
    the thread pool configuration
  - getQueue
```
public java.util.Queue<java.lang.Runnable> getQueue()
```
    Returns:
    
    the task Queue
  - getSize
```
public final int getSize()
```
    Returns:
    
    the number of allocated threads in the thread pool
  - shutdownNow
```
public java.util.List<java.lang.Runnable> shutdownNow()
```
    Specified by:
    
    shutdownNow in interface java.util.concurrent.ExecutorService
  - shutdown
```
public void shutdown()
```
    Specified by:
    
    shutdown in interface java.util.concurrent.ExecutorService
  - isShutdown
```
public boolean isShutdown()
```
    Specified by:
    
    isShutdown in interface java.util.concurrent.ExecutorService
  - isTerminated
```
public boolean isTerminated()
```
    Specified by:
    
    isTerminated in interface java.util.concurrent.ExecutorService
  - awaitTermination
```
public boolean awaitTermination(long timeout,
                                java.util.concurrent.TimeUnit unit)
                         throws java.lang.InterruptedException
```
    Specified by:
    
    awaitTermination in interface java.util.concurrent.ExecutorService
    
    Throws:
    
    java.lang.InterruptedException
  - poisonAll
```
protected void poisonAll()
```
  - drain
```
protected static void drain(java.util.Queue<java.lang.Runnable> from,
                            java.util.Collection<java.lang.Runnable> to)
```
  - validateNewPoolSize
```
protected void validateNewPoolSize(int corePoolsize,
                                   int maxPoolSize)
```
  - beforeExecute
```
protected void beforeExecute(AbstractThreadPool.Worker worker,
                             java.lang.Thread t,
                             java.lang.Runnable r)
```
    Method invoked prior to executing the given Runnable in the given thread. This method is invoked by thread t that will execute task r, and may be used to re-initialize ThreadLocals, or to perform logging.
    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.
    
    Parameters:
    
    worker - the AbstractThreadPool.Worker, running the the thread t
    
    t - the thread that will run task r.
    
    r - the task that will be executed.
  - afterExecute
```
protected void afterExecute(AbstractThreadPool.Worker worker,
                            java.lang.Thread thread,
                            java.lang.Runnable r,
                            java.lang.Throwable t)
```
    Method invoked upon completion of execution of the given Runnable. This method is invoked by the thread that executed the task. If non-null, the Throwable is the uncaught RuntimeException or Error that caused execution to terminate abruptly.
    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.
    
    Parameters:
    
    worker - the AbstractThreadPool.Worker, running the the thread t
    
    thread -
    
    r - the runnable that has completed.
    
    t - the exception that caused termination, or null if execution completed normally.
  - onTaskCompletedEvent
```
protected void onTaskCompletedEvent(java.lang.Runnable task)
```
    This method will be invoked when a the specified Runnable has completed execution.
    
    Parameters:
    
    task - the unit of work that has completed processing
  - onWorkerStarted
```
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. This method is called from AbstractThreadPool.Worker's thread.
    
    Parameters:
    
    worker -
  - onWorkerExit
```
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. This method is called from AbstractThreadPool.Worker's thread.
    
    Parameters:
    
    worker -
  - onMaxNumberOfThreadsReached
```
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.
  - onTaskQueued
```
protected void onTaskQueued(java.lang.Runnable task)
```
    Method is called by a thread pool each time new task has been queued to a task queue.
    
    Parameters:
    
    task -
  - onTaskDequeued
```
protected void onTaskDequeued(java.lang.Runnable task)
```
    Method is called by a thread pool each time a task has been dequeued from a task queue.
    
    Parameters:
    
    task -
  - onTaskCancelled
```
protected void onTaskCancelled(java.lang.Runnable task)
```
    Method is called by a thread pool each time a dequeued task has been canceled instead of being processed.
    
    Parameters:
    
    task -
  - onTaskQueueOverflow
```
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. throws RejectedExecutionException
  - getMonitoringConfig
```
public MonitoringConfig<ThreadPoolProbe> getMonitoringConfig()
```
    Return the object associated MonitoringConfig.
    
    Specified by:
    
    getMonitoringConfig in interface MonitoringAware<ThreadPoolProbe>
    
    Returns:
    
    the object associated MonitoringConfig.
  - uncaughtException
```
public void uncaughtException(java.lang.Thread thread,
                              java.lang.Throwable throwable)
```
    Specified by:
    
    uncaughtException in interface java.lang.Thread.UncaughtExceptionHandler
  - getDefaultThreadFactory
```
protected final java.util.concurrent.ThreadFactory getDefaultThreadFactory()
```
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object

Class AbstractThreadPool

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.util.concurrent.AbstractExecutorService

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.concurrent.Executor

Field Detail

DEFAULT_MIN_THREAD_COUNT

DEFAULT_MAX_THREAD_COUNT

DEFAULT_MAX_TASKS_QUEUED

DEFAULT_IDLE_THREAD_KEEPALIVE_TIMEOUT

poison

stateLock

workers

running

config

transactionTimeoutMillis

delayedQueue

monitoringConfig

Constructor Detail

AbstractThreadPool

Method Detail

startWorker

getConfig

getQueue

getSize

shutdownNow

shutdown

isShutdown

isTerminated

awaitTermination

poisonAll

drain

validateNewPoolSize

beforeExecute

afterExecute

onTaskCompletedEvent

onWorkerStarted

onWorkerExit

onMaxNumberOfThreadsReached

onTaskQueued

onTaskDequeued

onTaskCancelled

onTaskQueueOverflow

getMonitoringConfig

uncaughtException

getDefaultThreadFactory

toString