org.jboss.threads

Class QueueExecutor

java.lang.Object

java.util.concurrent.AbstractExecutorService

org.jboss.threads.QueueExecutor

All Implemented Interfaces:

java.util.concurrent.Executor, java.util.concurrent.ExecutorService, BlockingExecutor, BlockingExecutorService, BoundedQueueThreadPoolExecutorMBean, BoundedThreadPoolExecutorMBean, ThreadExecutorMBean, ThreadPoolExecutorMBean, ShutdownListenable

public final class QueueExecutor
extends java.util.concurrent.AbstractExecutorService
implements BlockingExecutorService, BoundedQueueThreadPoolExecutorMBean, ShutdownListenable

An executor which uses a regular queue to hold tasks. The executor may be tuned at runtime in many ways.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
private class	QueueExecutor.Worker

Field Summary

Fields

Modifier and Type	Field and Description
private boolean	allowCoreThreadTimeout
private boolean	blocking
private int	coreThreads
private java.util.concurrent.locks.Condition	enqueueCondition
private java.util.concurrent.Executor	handoffExecutor
private long	keepAliveTime
private java.util.concurrent.TimeUnit	keepAliveTimeUnit
private int	largestPoolSize
private java.util.concurrent.locks.Lock	lock
private static org.jboss.logging.Logger	log
private int	maxThreads
private java.util.Queue<java.lang.Runnable>	queue
private int	rejectCount
private java.util.concurrent.locks.Condition	removeCondition
private SimpleShutdownListenable	shutdownListenable
private boolean	stop
private DirectExecutor	taskExecutor
private int	threadCount
private java.util.concurrent.locks.Condition	threadExitCondition
private java.util.concurrent.ThreadFactory	threadFactory
private java.util.Set<java.lang.Thread>	workers

Constructor Summary

Constructors

Constructor and Description
QueueExecutor(int coreThreads, int maxThreads, long keepAliveTime, java.util.concurrent.TimeUnit keepAliveTimeUnit, int queueLength, java.util.concurrent.ThreadFactory threadFactory, boolean blocking, java.util.concurrent.Executor handoffExecutor) Create a new instance.
QueueExecutor(int coreThreads, int maxThreads, long keepAliveTime, java.util.concurrent.TimeUnit keepAliveTimeUnit, java.util.Queue<java.lang.Runnable> queue, java.util.concurrent.ThreadFactory threadFactory, boolean blocking, java.util.concurrent.Executor handoffExecutor) Create a new instance.
QueueExecutor(int coreThreads, int maxThreads, long keepAliveTime, java.util.concurrent.TimeUnit keepAliveTimeUnit, java.util.Queue<java.lang.Runnable> queue, java.util.concurrent.ThreadFactory threadFactory, boolean blocking, java.util.concurrent.Executor handoffExecutor, DirectExecutor taskExecutor) Create a new instance.

Method Summary

Modifier and Type	Method and Description
<A> void	addShutdownListener(EventListener<A> shutdownListener, A attachment) Add a shutdown listener.
boolean	awaitTermination(long timeout, java.util.concurrent.TimeUnit unit)
void	execute(java.lang.Runnable task) Execute a task.
void	executeBlocking(java.lang.Runnable task) Execute a task, blocking until it can be accepted, or until the calling thread is interrupted.
void	executeBlocking(java.lang.Runnable task, long timeout, java.util.concurrent.TimeUnit unit) Execute a task, blocking until it can be accepted, a timeout elapses, or the calling thread is interrupted.
void	executeNonBlocking(java.lang.Runnable task) Execute a task, without blocking.
int	getCoreThreads()
int	getCurrentThreadCount()
java.util.concurrent.Executor	getHandoffExecutor() Get the handoff executor which is called when a task cannot be accepted immediately.
long	getKeepAliveTime()
int	getLargestThreadCount()
int	getMaxThreads()
int	getQueueSize()
int	getRejectedCount()
boolean	isAllowCoreThreadTimeout()
boolean	isBlocking() Determine whether this thread pool executor is set to block when a task cannot be accepted immediately.
boolean	isShutdown()
boolean	isTerminated()
private java.lang.Runnable	pollTask()
private void	runTask(java.lang.Runnable task)
void	setAllowCoreThreadTimeout(boolean allowCoreThreadTimeout)
void	setBlocking(boolean blocking) Set whether this thread pool executor should be set to block when a task cannot be accepted immediately.
void	setCoreThreads(int coreThreads)
void	setHandoffExecutor(java.util.concurrent.Executor handoffExecutor) Set the handoff executor which is called when a task cannot be accepted immediately.
void	setKeepAliveTime(long milliseconds)
void	setKeepAliveTime(long keepAliveTime, java.util.concurrent.TimeUnit keepAliveTimeUnit) Set the keep-alive time to the given amount of time.
void	setMaxThreads(int maxThreads)
void	shutdown()
java.util.List<java.lang.Runnable>	shutdownNow()
private void	startNewThread(java.lang.Runnable task)
private java.lang.Runnable	takeTask()

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, toString, wait, wait, wait

Methods inherited from interface java.util.concurrent.ExecutorService

invokeAll, invokeAll, invokeAny, invokeAny, submit, submit, submit

Field Detail

log

private static final org.jboss.logging.Logger log

shutdownListenable

private final SimpleShutdownListenable shutdownListenable

lock

private final java.util.concurrent.locks.Lock lock

enqueueCondition

private final java.util.concurrent.locks.Condition enqueueCondition

removeCondition

private final java.util.concurrent.locks.Condition removeCondition

threadExitCondition

private final java.util.concurrent.locks.Condition threadExitCondition

threadFactory

private final java.util.concurrent.ThreadFactory threadFactory

taskExecutor

private final DirectExecutor taskExecutor

coreThreads

private int coreThreads

maxThreads

private int maxThreads

largestPoolSize

private int largestPoolSize

rejectCount

private int rejectCount

allowCoreThreadTimeout

private boolean allowCoreThreadTimeout

keepAliveTime

private long keepAliveTime

keepAliveTimeUnit

private java.util.concurrent.TimeUnit keepAliveTimeUnit

blocking

private boolean blocking

handoffExecutor

private java.util.concurrent.Executor handoffExecutor

threadCount

private int threadCount

workers

private java.util.Set<java.lang.Thread> workers

stop

private boolean stop

queue

private java.util.Queue<java.lang.Runnable> queue

Constructor Detail

QueueExecutor

public QueueExecutor(int coreThreads,
                     int maxThreads,
                     long keepAliveTime,
                     java.util.concurrent.TimeUnit keepAliveTimeUnit,
                     java.util.Queue<java.lang.Runnable> queue,
                     java.util.concurrent.ThreadFactory threadFactory,
                     boolean blocking,
                     java.util.concurrent.Executor handoffExecutor,
                     DirectExecutor taskExecutor)

Create a new instance.

Parameters:

coreThreads - the number of threads to create before enqueueing tasks

maxThreads - the maximum number of threads to create

keepAliveTime - the amount of time that an idle thread should remain active

keepAliveTimeUnit - the unit of time for keepAliveTime

queue - the queue to use for tasks

threadFactory - the thread factory to use for new threads

blocking - true if the executor should block when the queue is full and no threads are available, false to use the handoff executor

handoffExecutor - the executor which is called when blocking is disabled and a task cannot be accepted, or null to reject the task

taskExecutor - the executor to use to execute tasks

QueueExecutor

public QueueExecutor(int coreThreads,
                     int maxThreads,
                     long keepAliveTime,
                     java.util.concurrent.TimeUnit keepAliveTimeUnit,
                     java.util.Queue<java.lang.Runnable> queue,
                     java.util.concurrent.ThreadFactory threadFactory,
                     boolean blocking,
                     java.util.concurrent.Executor handoffExecutor)

Create a new instance.

Parameters:

coreThreads - the number of threads to create before enqueueing tasks

maxThreads - the maximum number of threads to create

keepAliveTime - the amount of time that an idle thread should remain active

keepAliveTimeUnit - the unit of time for keepAliveTime

queue - the queue to use for tasks

threadFactory - the thread factory to use for new threads

blocking - true if the executor should block when the queue is full and no threads are available, false to use the handoff executor

handoffExecutor - the executor which is called when blocking is disabled and a task cannot be accepted, or null to reject the task

QueueExecutor

public QueueExecutor(int coreThreads,
                     int maxThreads,
                     long keepAliveTime,
                     java.util.concurrent.TimeUnit keepAliveTimeUnit,
                     int queueLength,
                     java.util.concurrent.ThreadFactory threadFactory,
                     boolean blocking,
                     java.util.concurrent.Executor handoffExecutor)

Create a new instance.

Parameters:

coreThreads - the number of threads to create before enqueueing tasks

maxThreads - the maximum number of threads to create

keepAliveTime - the amount of time that an idle thread should remain active

keepAliveTimeUnit - the unit of time for keepAliveTime

queueLength - the fixed queue length to use for tasks

threadFactory - the thread factory to use for new threads

blocking - true if the executor should block when the queue is full and no threads are available, false to use the handoff executor

handoffExecutor - the executor which is called when blocking is disabled and a task cannot be accepted, or null to reject the task

Method Detail

execute

public void execute(java.lang.Runnable task)
             throws java.util.concurrent.RejectedExecutionException

Execute a task.

Specified by:

execute in interface java.util.concurrent.Executor

Specified by:

execute in interface BlockingExecutor

Parameters:

task - the task to execute

Throws:

java.util.concurrent.RejectedExecutionException - when a task is rejected by the handoff executor

StoppedExecutorException - when the executor is terminating

ExecutionInterruptedException - when blocking is enabled and the current thread is interrupted before a task could be accepted

executeBlocking

public void executeBlocking(java.lang.Runnable task)
                     throws java.util.concurrent.RejectedExecutionException,
                            java.lang.InterruptedException

Execute a task, blocking until it can be accepted, or until the calling thread is interrupted.

Specified by:

executeBlocking in interface BlockingExecutor

Parameters:

task - the task to submit

Throws:

StoppedExecutorException - if the executor was shut down before the task was accepted

ThreadCreationException - if a thread could not be created for some reason

java.util.concurrent.RejectedExecutionException - if execution is rejected for some other reason

java.lang.InterruptedException - if the current thread was interrupted before the task could be accepted

java.lang.NullPointerException - if command is null

executeBlocking

public void executeBlocking(java.lang.Runnable task,
                            long timeout,
                            java.util.concurrent.TimeUnit unit)
                     throws java.util.concurrent.RejectedExecutionException,
                            java.lang.InterruptedException

Execute a task, blocking until it can be accepted, a timeout elapses, or the calling thread is interrupted.

Specified by:

executeBlocking in interface BlockingExecutor

Parameters:

task - the task to submit

timeout - the amount of time to wait

unit - the unit of time

Throws:

ExecutionTimedOutException - if the timeout elapsed before a task could be accepted

StoppedExecutorException - if the executor was shut down before the task was accepted

ThreadCreationException - if a thread could not be created for some reason

java.util.concurrent.RejectedExecutionException - if execution is rejected for some other reason

java.lang.InterruptedException - if the current thread was interrupted before the task could be accepted

java.lang.NullPointerException - if command is null

executeNonBlocking

public void executeNonBlocking(java.lang.Runnable task)
                        throws java.util.concurrent.RejectedExecutionException

Execute a task, without blocking.

Specified by:

executeNonBlocking in interface BlockingExecutor

Parameters:

task - the task to submit

Throws:

StoppedExecutorException - if the executor was shut down before the task was accepted

ThreadCreationException - if a thread could not be created for some reason

java.util.concurrent.RejectedExecutionException - if execution is rejected for some other reason

java.lang.NullPointerException - if command is null

shutdown

public void shutdown()

Specified by:

shutdown in interface java.util.concurrent.ExecutorService

shutdownNow

public java.util.List<java.lang.Runnable> shutdownNow()

Specified by:

shutdownNow 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

isAllowCoreThreadTimeout

public boolean isAllowCoreThreadTimeout()

Specified by:

isAllowCoreThreadTimeout in interface BoundedQueueThreadPoolExecutorMBean

setAllowCoreThreadTimeout

public void setAllowCoreThreadTimeout(boolean allowCoreThreadTimeout)

Specified by:

setAllowCoreThreadTimeout in interface BoundedQueueThreadPoolExecutorMBean

getCoreThreads

public int getCoreThreads()

Specified by:

getCoreThreads in interface BoundedQueueThreadPoolExecutorMBean

setCoreThreads

public void setCoreThreads(int coreThreads)

Specified by:

setCoreThreads in interface BoundedQueueThreadPoolExecutorMBean

getMaxThreads

public int getMaxThreads()

Specified by:

getMaxThreads in interface ThreadPoolExecutorMBean

setMaxThreads

public void setMaxThreads(int maxThreads)

Specified by:

setMaxThreads in interface ThreadPoolExecutorMBean

getKeepAliveTime

public long getKeepAliveTime()

Specified by:

getKeepAliveTime in interface ThreadPoolExecutorMBean

setKeepAliveTime

public void setKeepAliveTime(long keepAliveTime,
                             java.util.concurrent.TimeUnit keepAliveTimeUnit)

Set the keep-alive time to the given amount of time.

Parameters:

keepAliveTime - the amount of time

keepAliveTimeUnit - the unit of time

setKeepAliveTime

public void setKeepAliveTime(long milliseconds)

Specified by:

setKeepAliveTime in interface ThreadPoolExecutorMBean

isBlocking

public boolean isBlocking()

Determine whether this thread pool executor is set to block when a task cannot be accepted immediately.

Specified by:

isBlocking in interface BoundedThreadPoolExecutorMBean

Returns:

true if blocking is enabled, false if the handoff executor is used

setBlocking

public void setBlocking(boolean blocking)

Set whether this thread pool executor should be set to block when a task cannot be accepted immediately.

Specified by:

setBlocking in interface BoundedThreadPoolExecutorMBean

Parameters:

blocking - true if blocking is enabled, false if the handoff executor is used

getHandoffExecutor

public java.util.concurrent.Executor getHandoffExecutor()

Get the handoff executor which is called when a task cannot be accepted immediately.

Returns:

the handoff executor

setHandoffExecutor

public void setHandoffExecutor(java.util.concurrent.Executor handoffExecutor)

Set the handoff executor which is called when a task cannot be accepted immediately.

Parameters:

handoffExecutor - the handoff executor

addShutdownListener

public <A> void addShutdownListener(EventListener<A> shutdownListener,
                                    A attachment)

Add a shutdown listener. If the target object is already shut down, the listener is invoked directly.

Specified by:

addShutdownListener in interface ShutdownListenable

Type Parameters:

A - the attachment type

Parameters:

shutdownListener - the listener

attachment - the attachment value to pass to the listener

startNewThread

private void startNewThread(java.lang.Runnable task)

pollTask

private java.lang.Runnable pollTask()

takeTask

private java.lang.Runnable takeTask()

getCurrentThreadCount

public int getCurrentThreadCount()

Specified by:

getCurrentThreadCount in interface ThreadExecutorMBean

getLargestThreadCount

public int getLargestThreadCount()

Specified by:

getLargestThreadCount in interface ThreadExecutorMBean

getRejectedCount

public int getRejectedCount()

Specified by:

getRejectedCount in interface ThreadExecutorMBean

getQueueSize

public int getQueueSize()

Specified by:

getQueueSize in interface ThreadExecutorMBean

runTask

private void runTask(java.lang.Runnable task)