org.glassfish.grizzly.threadpool
Class AbstractThreadPool

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, JmxMonitoringAware<ThreadPoolProbe>, MonitoringAware<ThreadPoolProbe>

Direct Known Subclasses:

FixedThreadPool, SyncThreadPool

public abstract class AbstractThreadPool
extends java.util.concurrent.AbstractExecutorService
implements java.lang.Thread.UncaughtExceptionHandler, JmxMonitoringAware<ThreadPoolProbe>

Abstract ExecutorService implementation.

Author:

Alexey Stashok

Nested Class Summary

class

AbstractThreadPool.Worker

Field Summary

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 AbstractJmxMonitoringConfig<ThreadPoolProbe>	monitoringConfig ThreadPool probes
protected static java.lang.Runnable	poison
protected boolean	running
protected java.util.concurrent.locks.ReentrantLock	stateLock
protected java.util.concurrent.locks.Condition	stateLockCondition Wait condition to support awaitTermination
protected long	transactionTimeoutMillis
protected java.util.Map<AbstractThreadPool.Worker,java.lang.Long>	workers

Constructor Summary

AbstractThreadPool(ThreadPoolConfig config)

Method Summary

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()
JmxMonitoringConfig<ThreadPoolProbe>	getMonitoringConfig() Return the object associated JmxMonitoringConfig.
java.util.Queue<java.lang.Runnable>	getQueue()
boolean	isShutdown()
boolean	isTerminated()
protected java.lang.String	nextThreadId()
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(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.util.concurrent.locks.ReentrantLock stateLock

stateLockCondition

protected final java.util.concurrent.locks.Condition stateLockCondition

Wait condition to support awaitTermination

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

getQueue

public java.util.Queue<java.lang.Runnable> getQueue()

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)

nextThreadId

protected java.lang.String nextThreadId()

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 -

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 JmxMonitoringConfig<ThreadPoolProbe> getMonitoringConfig()

Return the object associated JmxMonitoringConfig.

Specified by:

getMonitoringConfig in interface JmxMonitoringAware<ThreadPoolProbe>

Specified by:

getMonitoringConfig in interface MonitoringAware<ThreadPoolProbe>

Returns:

the object associated JmxMonitoringConfig.

uncaughtException

public void uncaughtException(java.lang.Thread thread,
                              java.lang.Throwable throwable)

Specified by:

uncaughtException in interface java.lang.Thread.UncaughtExceptionHandler

getDefaultThreadFactory

protected java.util.concurrent.ThreadFactory getDefaultThreadFactory()

toString

public java.lang.String toString()

Overrides:

toString in class java.lang.Object