java.lang.Object
- java.util.concurrent.AbstractExecutorService
- - java.util.concurrent.ThreadPoolExecutor
  - - org.apache.mina.filter.executor.PriorityThreadPoolExecutor

All Implemented Interfaces:

java.util.concurrent.Executor, java.util.concurrent.ExecutorService
```
public class PriorityThreadPoolExecutor
extends java.util.concurrent.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 java.util.concurrent.ThreadPoolExecutor
java.util.concurrent.ThreadPoolExecutor.AbortPolicy, java.util.concurrent.ThreadPoolExecutor.CallerRunsPolicy, java.util.concurrent.ThreadPoolExecutor.DiscardOldestPolicy, java.util.concurrent.ThreadPoolExecutor.DiscardPolicy

Field Summary

Fields
Modifier and Type	Field	Description
`private java.util.Comparator<IoSession>`	`comparator`	The session comparator
`private long`	`completedTaskCount`
`private static int`	`DEFAULT_INITIAL_THREAD_POOL_SIZE`	A default value for the initial pool size
`private static int`	`DEFAULT_KEEP_ALIVE`	A default value for the KeepAlive delay
`private static int`	`DEFAULT_MAX_THREAD_POOL`	A default value for the maximum pool size
`private IoEventQueueHandler`	`eventQueueHandler`
`private static PriorityThreadPoolExecutor.SessionEntry`	`EXIT_SIGNAL`
`private java.util.concurrent.atomic.AtomicInteger`	`idleWorkers`
`private int`	`largestPoolSize`
`private static org.slf4j.Logger`	`LOGGER`	A logger for this class (commented as it breaks MDCFlter tests)
`private static java.util.concurrent.atomic.AtomicLong`	`seq`	Generates sequential identifiers that ensure FIFO behavior.
`private boolean`	`shutdown`
`private static AttributeKey`	`TASKS_QUEUE`	A key stored into the session's attribute for the event tasks being queued
`private java.util.concurrent.BlockingQueue<PriorityThreadPoolExecutor.SessionEntry>`	`waitingSessions`	A queue used to store the available sessions
`private java.util.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, java.util.concurrent.TimeUnit unit)`	Creates a default ThreadPool, with default values : minimum pool size is 0 A default ThreadFactory
`PriorityThreadPoolExecutor(int minimumPoolSize, int maximumPoolSize, long keepAliveTime, java.util.concurrent.TimeUnit unit, java.util.concurrent.ThreadFactory threadFactory)`	Creates a default ThreadPool
`PriorityThreadPoolExecutor(int minimumPoolSize, int maximumPoolSize, long keepAliveTime, java.util.concurrent.TimeUnit unit, java.util.concurrent.ThreadFactory threadFactory, IoEventQueueHandler eventQueueHandler, java.util.Comparator<IoSession> comparator)`	Creates a new instance of a PrioritisedOrderedThreadPoolExecutor.
`PriorityThreadPoolExecutor(int minimumPoolSize, int maximumPoolSize, long keepAliveTime, java.util.concurrent.TimeUnit unit, IoEventQueueHandler eventQueueHandler)`	Creates a default ThreadPool, with default values : A default ThreadFactory
`PriorityThreadPoolExecutor(int maximumPoolSize, java.util.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(java.util.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

All Methods Instance Methods Concrete Methods
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, java.util.concurrent.TimeUnit unit)`
`private void`	`checkTaskType(java.lang.Runnable task)`
`void`	`execute(java.lang.Runnable task)`
`int`	`getActiveCount()`
`long`	`getCompletedTaskCount()`
`int`	`getLargestPoolSize()`
`int`	`getPoolSize()`
`java.util.concurrent.BlockingQueue<java.lang.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(java.util.Queue<java.lang.Runnable> queue, IoEvent event)`	A Helper class used to print the list of events being queued.
`void`	`purge()`
`private void`	`rejectTask(java.lang.Runnable task)`
`boolean`	`remove(java.lang.Runnable task)`
`private void`	`removeWorker()`
`void`	`setCorePoolSize(int minimumPoolSize)`
`void`	`setMaximumPoolSize(int maximumPoolSize)`
`void`	`setRejectedExecutionHandler(java.util.concurrent.RejectedExecutionHandler handler)`
`void`	`shutdown()`
`java.util.List<java.lang.Runnable>`	`shutdownNow()`

Methods inherited from class java.util.concurrent.ThreadPoolExecutor
afterExecute, allowCoreThreadTimeOut, allowsCoreThreadTimeOut, beforeExecute, finalize, getCorePoolSize, getKeepAliveTime, getMaximumPoolSize, getRejectedExecutionHandler, getThreadFactory, setKeepAliveTime, setThreadFactory, terminated, toString

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, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - LOGGER
```
private static final org.slf4j.Logger LOGGER
```
    A logger for this class (commented as it breaks MDCFlter tests)
  - seq
```
private static final java.util.concurrent.atomic.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 java.util.concurrent.BlockingQueue<PriorityThreadPoolExecutor.SessionEntry> waitingSessions
```
    A queue used to store the available sessions
  - workers
```
private final java.util.Set<PriorityThreadPoolExecutor.Worker> workers
```
  - largestPoolSize
```
private volatile int largestPoolSize
```
  - idleWorkers
```
private final java.util.concurrent.atomic.AtomicInteger idleWorkers
```
  - completedTaskCount
```
private long completedTaskCount
```
  - shutdown
```
private volatile boolean shutdown
```
  - eventQueueHandler
```
private final IoEventQueueHandler eventQueueHandler
```
  - comparator
```
private final java.util.Comparator<IoSession> comparator
```
    The session comparator
- Constructor Detail
  - 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(java.util.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,
                                  java.util.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,
                                  java.util.concurrent.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,
                                  java.util.concurrent.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,
                                  java.util.concurrent.TimeUnit unit,
                                  java.util.concurrent.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,
                                  java.util.concurrent.TimeUnit unit,
                                  java.util.concurrent.ThreadFactory threadFactory,
                                  IoEventQueueHandler eventQueueHandler,
                                  java.util.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 Detail
  - 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(java.util.concurrent.RejectedExecutionHandler handler)
```
    Overrides:
    
    setRejectedExecutionHandler in class java.util.concurrent.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 java.util.concurrent.ThreadPoolExecutor
  - awaitTermination
```
public boolean awaitTermination(long timeout,
                                java.util.concurrent.TimeUnit unit)
                         throws java.lang.InterruptedException
```
    Specified by:
    
    awaitTermination in interface java.util.concurrent.ExecutorService
    
    Overrides:
    
    awaitTermination in class java.util.concurrent.ThreadPoolExecutor
    
    Throws:
    
    java.lang.InterruptedException
  - isShutdown
```
public boolean isShutdown()
```
    Specified by:
    
    isShutdown in interface java.util.concurrent.ExecutorService
    
    Overrides:
    
    isShutdown in class java.util.concurrent.ThreadPoolExecutor
  - isTerminated
```
public boolean isTerminated()
```
    Specified by:
    
    isTerminated in interface java.util.concurrent.ExecutorService
    
    Overrides:
    
    isTerminated in class java.util.concurrent.ThreadPoolExecutor
  - shutdown
```
public void shutdown()
```
    Specified by:
    
    shutdown in interface java.util.concurrent.ExecutorService
    
    Overrides:
    
    shutdown in class java.util.concurrent.ThreadPoolExecutor
  - shutdownNow
```
public java.util.List<java.lang.Runnable> shutdownNow()
```
    Specified by:
    
    shutdownNow in interface java.util.concurrent.ExecutorService
    
    Overrides:
    
    shutdownNow in class java.util.concurrent.ThreadPoolExecutor
  - print
```
private void print(java.util.Queue<java.lang.Runnable> queue,
                   IoEvent event)
```
    A Helper class used to print the list of events being queued.
  - execute
```
public void execute(java.lang.Runnable task)
```
    Specified by:
    
    execute in interface java.util.concurrent.Executor
    
    Overrides:
    
    execute in class java.util.concurrent.ThreadPoolExecutor
  - rejectTask
```
private void rejectTask(java.lang.Runnable task)
```
  - checkTaskType
```
private void checkTaskType(java.lang.Runnable task)
```
  - getActiveCount
```
public int getActiveCount()
```
    Overrides:
    
    getActiveCount in class java.util.concurrent.ThreadPoolExecutor
  - getCompletedTaskCount
```
public long getCompletedTaskCount()
```
    Overrides:
    
    getCompletedTaskCount in class java.util.concurrent.ThreadPoolExecutor
  - getLargestPoolSize
```
public int getLargestPoolSize()
```
    Overrides:
    
    getLargestPoolSize in class java.util.concurrent.ThreadPoolExecutor
  - getPoolSize
```
public int getPoolSize()
```
    Overrides:
    
    getPoolSize in class java.util.concurrent.ThreadPoolExecutor
  - getTaskCount
```
public long getTaskCount()
```
    Overrides:
    
    getTaskCount in class java.util.concurrent.ThreadPoolExecutor
  - isTerminating
```
public boolean isTerminating()
```
    Overrides:
    
    isTerminating in class java.util.concurrent.ThreadPoolExecutor
  - prestartAllCoreThreads
```
public int prestartAllCoreThreads()
```
    Overrides:
    
    prestartAllCoreThreads in class java.util.concurrent.ThreadPoolExecutor
  - prestartCoreThread
```
public boolean prestartCoreThread()
```
    Overrides:
    
    prestartCoreThread in class java.util.concurrent.ThreadPoolExecutor
  - getQueue
```
public java.util.concurrent.BlockingQueue<java.lang.Runnable> getQueue()
```
    Overrides:
    
    getQueue in class java.util.concurrent.ThreadPoolExecutor
  - purge
```
public void purge()
```
    Overrides:
    
    purge in class java.util.concurrent.ThreadPoolExecutor
  - remove
```
public boolean remove(java.lang.Runnable task)
```
    Overrides:
    
    remove in class java.util.concurrent.ThreadPoolExecutor
  - setCorePoolSize
```
public void setCorePoolSize(int minimumPoolSize)
```
    Overrides:
    
    setCorePoolSize in class java.util.concurrent.ThreadPoolExecutor

Class PriorityThreadPoolExecutor

Nested Class Summary

Nested classes/interfaces inherited from class java.util.concurrent.ThreadPoolExecutor

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.util.concurrent.ThreadPoolExecutor

Methods inherited from class java.util.concurrent.AbstractExecutorService

Methods inherited from class java.lang.Object

Field Detail

LOGGER

seq

DEFAULT_INITIAL_THREAD_POOL_SIZE

DEFAULT_MAX_THREAD_POOL

DEFAULT_KEEP_ALIVE

EXIT_SIGNAL

TASKS_QUEUE

waitingSessions

workers

largestPoolSize

idleWorkers

completedTaskCount

shutdown

eventQueueHandler

comparator

Constructor Detail

PriorityThreadPoolExecutor

PriorityThreadPoolExecutor

PriorityThreadPoolExecutor

PriorityThreadPoolExecutor

PriorityThreadPoolExecutor

PriorityThreadPoolExecutor

PriorityThreadPoolExecutor

PriorityThreadPoolExecutor

PriorityThreadPoolExecutor

Method Detail

getSessionTasksQueue

getQueueHandler

setRejectedExecutionHandler

addWorker

addWorkerIfNecessary

removeWorker

setMaximumPoolSize

awaitTermination

isShutdown

isTerminated

shutdown

shutdownNow

print

execute

rejectTask

checkTaskType

getActiveCount

getCompletedTaskCount

getLargestPoolSize

getPoolSize

getTaskCount

isTerminating

prestartAllCoreThreads

prestartCoreThread

getQueue

purge

remove

setCorePoolSize