Class PriorityThreadPoolExecutor

java.lang.Object

java.util.concurrent.AbstractExecutorService

java.util.concurrent.ThreadPoolExecutor

org.apache.mina.filter.executor.PriorityThreadPoolExecutor

All Implemented Interfaces:

Executor, ExecutorService

public class PriorityThreadPoolExecutor
extends ThreadPoolExecutor

A ThreadPoolExecutor that maintains the order of IoEvents within a session (similar to OrderedThreadPoolExecutor) and allows some sessions to be prioritized over other sessions.

If you don't need to maintain the order of events per session, please use UnorderedThreadPoolExecutor.

If you don't need to prioritize sessions, please use OrderedThreadPoolExecutor.

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
(package private) static class	PriorityThreadPoolExecutor.SessionEntry	A class used to preserve first-in-first-out order of sessions that have equal priority.
private class	PriorityThreadPoolExecutor.SessionQueue	A class used to store the ordered list of events to be processed by the session, and the current task state.
private class	PriorityThreadPoolExecutor.Worker

Nested classes/interfaces inherited from class ThreadPoolExecutor

ThreadPoolExecutor.AbortPolicy, ThreadPoolExecutor.CallerRunsPolicy, ThreadPoolExecutor.DiscardOldestPolicy, ThreadPoolExecutor.DiscardPolicy

Field Summary

Fields

Modifier and Type	Field	Description
private final Comparator<IoSession>	comparator	The session comparator
private long	completedTaskCount
private static final int	DEFAULT_INITIAL_THREAD_POOL_SIZE	A default value for the initial pool size
private static final int	DEFAULT_KEEP_ALIVE	A default value for the KeepAlive delay
private static final int	DEFAULT_MAX_THREAD_POOL	A default value for the maximum pool size
private final IoEventQueueHandler	eventQueueHandler
private static final PriorityThreadPoolExecutor.SessionEntry	EXIT_SIGNAL
private final AtomicInteger	idleWorkers
private int	largestPoolSize
private static final org.slf4j.Logger	LOGGER	A logger for this class (commented as it breaks MDCFlter tests)
private static final AtomicLong	seq	Generates sequential identifiers that ensure FIFO behavior.
private boolean	shutdown
private static final AttributeKey	TASKS_QUEUE	A key stored into the session's attribute for the event tasks being queued
private final BlockingQueue<PriorityThreadPoolExecutor.SessionEntry>	waitingSessions	A queue used to store the available sessions
private final Set<PriorityThreadPoolExecutor.Worker>	workers

Constructor Summary

Constructors

Constructor	Description
PriorityThreadPoolExecutor()	Creates a default ThreadPool, with default values : minimum pool size is 0 maximum pool size is 16 keepAlive set to 30 seconds A default ThreadFactory All events are accepted
PriorityThreadPoolExecutor(int maximumPoolSize)	Creates a default ThreadPool, with default values : minimum pool size is 0 keepAlive set to 30 seconds A default ThreadFactory All events are accepted
PriorityThreadPoolExecutor(int minimumPoolSize, int maximumPoolSize)	Creates a default ThreadPool, with default values : keepAlive set to 30 seconds A default ThreadFactory All events are accepted
PriorityThreadPoolExecutor(int minimumPoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit)	Creates a default ThreadPool, with default values : minimum pool size is 0 A default ThreadFactory
PriorityThreadPoolExecutor(int minimumPoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, ThreadFactory threadFactory)	Creates a default ThreadPool
PriorityThreadPoolExecutor(int minimumPoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, ThreadFactory threadFactory, IoEventQueueHandler eventQueueHandler, Comparator<IoSession> comparator)	Creates a new instance of a PrioritisedOrderedThreadPoolExecutor.
PriorityThreadPoolExecutor(int minimumPoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, IoEventQueueHandler eventQueueHandler)	Creates a default ThreadPool, with default values : A default ThreadFactory
PriorityThreadPoolExecutor(int maximumPoolSize, Comparator<IoSession> comparator)	Creates a default ThreadPool, with default values : maximum pool size is 16 keepAlive set to 30 seconds A default ThreadFactory All events are accepted
PriorityThreadPoolExecutor(Comparator<IoSession> comparator)	Creates a default ThreadPool, with default values : minimum pool size is 0 maximum pool size is 16 keepAlive set to 30 seconds A default ThreadFactory All events are accepted

Method Summary

Modifier and Type	Method	Description
private void	addWorker()	Add a new thread to execute a task, if needed and possible.
private void	addWorkerIfNecessary()	Add a new Worker only if there are no idle worker.
boolean	awaitTermination(long timeout, TimeUnit unit)
private void	checkTaskType(Runnable task)
void	execute(Runnable task)
int	getActiveCount()
long	getCompletedTaskCount()
int	getLargestPoolSize()
int	getPoolSize()
BlockingQueue<Runnable>	getQueue()
IoEventQueueHandler	getQueueHandler()
private PriorityThreadPoolExecutor.SessionQueue	getSessionTasksQueue(IoSession session)	Get the session's tasks queue.
long	getTaskCount()
boolean	isShutdown()
boolean	isTerminated()
boolean	isTerminating()
int	prestartAllCoreThreads()
boolean	prestartCoreThread()
private void	print(Queue<Runnable> queue, IoEvent event)	A Helper class used to print the list of events being queued.
void	purge()
private void	rejectTask(Runnable task)
boolean	remove(Runnable task)
private void	removeWorker()
void	setCorePoolSize(int minimumPoolSize)
void	setMaximumPoolSize(int maximumPoolSize)
void	setRejectedExecutionHandler(RejectedExecutionHandler handler)
void	shutdown()
List<Runnable>	shutdownNow()

Methods inherited from class ThreadPoolExecutor

afterExecute, allowCoreThreadTimeOut, allowsCoreThreadTimeOut, beforeExecute, finalize, getCorePoolSize, getKeepAliveTime, getMaximumPoolSize, getRejectedExecutionHandler, getThreadFactory, setKeepAliveTime, setThreadFactory, terminated, toString

Methods inherited from class AbstractExecutorService

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

Methods inherited from class Object

clone, equals, getClass, hashCode, notify, notifyAll, wait, wait, wait

Field Details

LOGGER

private static final org.slf4j.Logger LOGGER

A logger for this class (commented as it breaks MDCFlter tests)

seq

private static final AtomicLong seq

Generates sequential identifiers that ensure FIFO behavior.

DEFAULT_INITIAL_THREAD_POOL_SIZE

private static final int DEFAULT_INITIAL_THREAD_POOL_SIZE

A default value for the initial pool size

See Also:

• Constant Field Values

DEFAULT_MAX_THREAD_POOL

private static final int DEFAULT_MAX_THREAD_POOL

A default value for the maximum pool size

See Also:

• Constant Field Values

DEFAULT_KEEP_ALIVE

private static final int DEFAULT_KEEP_ALIVE

A default value for the KeepAlive delay

See Also:

• Constant Field Values

EXIT_SIGNAL

private static final PriorityThreadPoolExecutor.SessionEntry EXIT_SIGNAL

TASKS_QUEUE

private static final AttributeKey TASKS_QUEUE

A key stored into the session's attribute for the event tasks being queued

waitingSessions

private final BlockingQueue<PriorityThreadPoolExecutor.SessionEntry> waitingSessions

A queue used to store the available sessions

workers

private final Set<PriorityThreadPoolExecutor.Worker> workers

largestPoolSize

private volatile int largestPoolSize

idleWorkers

private final AtomicInteger idleWorkers

completedTaskCount

private long completedTaskCount

shutdown

private volatile boolean shutdown

eventQueueHandler

private final IoEventQueueHandler eventQueueHandler

comparator

private final Comparator<IoSession> comparator

The session comparator

Constructor Details

PriorityThreadPoolExecutor

public PriorityThreadPoolExecutor()

Creates a default ThreadPool, with default values :

• minimum pool size is 0
• maximum pool size is 16
• keepAlive set to 30 seconds
• A default ThreadFactory
• All events are accepted

PriorityThreadPoolExecutor

public PriorityThreadPoolExecutor(Comparator<IoSession> comparator)

Creates a default ThreadPool, with default values :

• minimum pool size is 0
• maximum pool size is 16
• keepAlive set to 30 seconds
• A default ThreadFactory
• All events are accepted

Parameters:

comparator - A session comparator

PriorityThreadPoolExecutor

public PriorityThreadPoolExecutor(int maximumPoolSize)

Creates a default ThreadPool, with default values :

• minimum pool size is 0
• keepAlive set to 30 seconds
• A default ThreadFactory
• All events are accepted

Parameters:

maximumPoolSize - The maximum pool size

PriorityThreadPoolExecutor

public PriorityThreadPoolExecutor(int maximumPoolSize,
 Comparator<IoSession> comparator)

Creates a default ThreadPool, with default values :

• maximum pool size is 16
• keepAlive set to 30 seconds
• A default ThreadFactory
• All events are accepted

Parameters:

maximumPoolSize - The maximum pool size

comparator - A session comparator

PriorityThreadPoolExecutor

public PriorityThreadPoolExecutor(int minimumPoolSize,
 int maximumPoolSize)

Creates a default ThreadPool, with default values :

• keepAlive set to 30 seconds
• A default ThreadFactory
• All events are accepted

Parameters:

minimumPoolSize - The initial pool size

maximumPoolSize - The maximum pool size

PriorityThreadPoolExecutor

public PriorityThreadPoolExecutor(int minimumPoolSize,
 int maximumPoolSize,
 long keepAliveTime,
 TimeUnit unit)

Creates a default ThreadPool, with default values :

• minimum pool size is 0
• A default ThreadFactory

Parameters:

minimumPoolSize - The initial pool size

maximumPoolSize - The maximum pool size

keepAliveTime - Default duration for a thread

unit - Time unit used for the keepAlive value

PriorityThreadPoolExecutor

public PriorityThreadPoolExecutor(int minimumPoolSize,
 int maximumPoolSize,
 long keepAliveTime,
 TimeUnit unit,
 IoEventQueueHandler eventQueueHandler)

Creates a default ThreadPool, with default values :

• A default ThreadFactory

Parameters:

minimumPoolSize - The initial pool size

maximumPoolSize - The maximum pool size

keepAliveTime - Default duration for a thread

unit - Time unit used for the keepAlive value

eventQueueHandler - The queue used to store events

PriorityThreadPoolExecutor

public PriorityThreadPoolExecutor(int minimumPoolSize,
 int maximumPoolSize,
 long keepAliveTime,
 TimeUnit unit,
 ThreadFactory threadFactory)

Creates a default ThreadPool

Parameters:

minimumPoolSize - The initial pool size

maximumPoolSize - The maximum pool size

keepAliveTime - Default duration for a thread

unit - Time unit used for the keepAlive value

threadFactory - The factory used to create threads

PriorityThreadPoolExecutor

public PriorityThreadPoolExecutor(int minimumPoolSize,
 int maximumPoolSize,
 long keepAliveTime,
 TimeUnit unit,
 ThreadFactory threadFactory,
 IoEventQueueHandler eventQueueHandler,
 Comparator<IoSession> comparator)

Creates a new instance of a PrioritisedOrderedThreadPoolExecutor.

Parameters:

minimumPoolSize - The initial pool sizePoolSize

maximumPoolSize - The maximum pool size

keepAliveTime - Default duration for a thread

unit - Time unit used for the keepAlive value

threadFactory - The factory used to create threads

eventQueueHandler - The queue used to store events

comparator - A session comparator

Method Details

getSessionTasksQueue

private PriorityThreadPoolExecutor.SessionQueue getSessionTasksQueue(IoSession session)

Get the session's tasks queue.

getQueueHandler

public IoEventQueueHandler getQueueHandler()

Returns:

The associated queue handler.

setRejectedExecutionHandler

public void setRejectedExecutionHandler(RejectedExecutionHandler handler)

Overrides:

setRejectedExecutionHandler in class ThreadPoolExecutor

addWorker

private void addWorker()

Add a new thread to execute a task, if needed and possible. It depends on the current pool size. If it's full, we do nothing.

addWorkerIfNecessary

private void addWorkerIfNecessary()

Add a new Worker only if there are no idle worker.

removeWorker

private void removeWorker()

setMaximumPoolSize

public void setMaximumPoolSize(int maximumPoolSize)

Overrides:

setMaximumPoolSize in class ThreadPoolExecutor

awaitTermination

public boolean awaitTermination(long timeout,
 TimeUnit unit)
                         throws InterruptedException

Specified by:

awaitTermination in interface ExecutorService

Overrides:

awaitTermination in class ThreadPoolExecutor

Throws:

InterruptedException

isShutdown

public boolean isShutdown()

Specified by:

isShutdown in interface ExecutorService

Overrides:

isShutdown in class ThreadPoolExecutor

isTerminated

public boolean isTerminated()

Specified by:

isTerminated in interface ExecutorService

Overrides:

isTerminated in class ThreadPoolExecutor

shutdown

public void shutdown()

Specified by:

shutdown in interface ExecutorService

Overrides:

shutdown in class ThreadPoolExecutor

shutdownNow

public List<Runnable> shutdownNow()

Specified by:

shutdownNow in interface ExecutorService

Overrides:

shutdownNow in class ThreadPoolExecutor

print

private void print(Queue<Runnable> queue,
 IoEvent event)

A Helper class used to print the list of events being queued.

execute

public void execute(Runnable task)

Specified by:

execute in interface Executor

Overrides:

execute in class ThreadPoolExecutor

rejectTask

private void rejectTask(Runnable task)

checkTaskType

private void checkTaskType(Runnable task)

getActiveCount

public int getActiveCount()

Overrides:

getActiveCount in class ThreadPoolExecutor

getCompletedTaskCount

public long getCompletedTaskCount()

Overrides:

getCompletedTaskCount in class ThreadPoolExecutor

getLargestPoolSize

public int getLargestPoolSize()

Overrides:

getLargestPoolSize in class ThreadPoolExecutor

getPoolSize

public int getPoolSize()

Overrides:

getPoolSize in class ThreadPoolExecutor

getTaskCount

public long getTaskCount()

Overrides:

getTaskCount in class ThreadPoolExecutor

isTerminating

public boolean isTerminating()

Overrides:

isTerminating in class ThreadPoolExecutor

prestartAllCoreThreads

public int prestartAllCoreThreads()

Overrides:

prestartAllCoreThreads in class ThreadPoolExecutor

prestartCoreThread

public boolean prestartCoreThread()

Overrides:

prestartCoreThread in class ThreadPoolExecutor

getQueue

public BlockingQueue<Runnable> getQueue()

Overrides:

getQueue in class ThreadPoolExecutor

purge

public void purge()

Overrides:

purge in class ThreadPoolExecutor

remove

public boolean remove(Runnable task)

Overrides:

remove in class ThreadPoolExecutor

setCorePoolSize

public void setCorePoolSize(int minimumPoolSize)

Overrides:

setCorePoolSize in class ThreadPoolExecutor