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

All Implemented Interfaces:

java.util.concurrent.Executor, java.util.concurrent.ExecutorService
```
public class OrderedThreadPoolExecutor
extends java.util.concurrent.ThreadPoolExecutor
```
A ThreadPoolExecutor that maintains the order of IoEvents.
If you don't need to maintain the order of events per session, please use UnorderedThreadPoolExecutor.

Nested Class Summary

Nested Classes
Modifier and Type	Class	Description
`private class`	`OrderedThreadPoolExecutor.SessionTasksQueue`	A class used to store the ordered list of events to be processed by the session, and the current task state.
`private class`	`OrderedThreadPoolExecutor.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 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 IoSession`	`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 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<IoSession>`	`waitingSessions`	A queue used to store the available sessions
`private java.util.Set<OrderedThreadPoolExecutor.Worker>`	`workers`

Constructor Summary

Constructors
Constructor	Description
`OrderedThreadPoolExecutor()`	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
`OrderedThreadPoolExecutor(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
`OrderedThreadPoolExecutor(int corePoolSize, int maximumPoolSize)`	Creates a default ThreadPool, with default values : - keepAlive set to 30 seconds - A default ThreadFactory - All events are accepted
`OrderedThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, java.util.concurrent.TimeUnit unit)`	Creates a default ThreadPool, with default values : - A default ThreadFactory - All events are accepted
`OrderedThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, java.util.concurrent.TimeUnit unit, java.util.concurrent.ThreadFactory threadFactory)`	Creates a default ThreadPool, with default values : - A default ThreadFactory
`OrderedThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, java.util.concurrent.TimeUnit unit, java.util.concurrent.ThreadFactory threadFactory, IoEventQueueHandler eventQueueHandler)`	Creates a new instance of a OrderedThreadPoolExecutor.
`OrderedThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, java.util.concurrent.TimeUnit unit, IoEventQueueHandler eventQueueHandler)`	Creates a default ThreadPool, with default values : - A default ThreadFactory

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 OrderedThreadPoolExecutor.SessionTasksQueue`	`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 corePoolSize)`
`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)
  - 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 IoSession 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<IoSession> waitingSessions
```
    A queue used to store the available sessions
  - workers
```
private final java.util.Set<OrderedThreadPoolExecutor.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
```
- Constructor Detail
  - OrderedThreadPoolExecutor
```
public OrderedThreadPoolExecutor()
```
    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
  - OrderedThreadPoolExecutor
```
public OrderedThreadPoolExecutor(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
  - OrderedThreadPoolExecutor
```
public OrderedThreadPoolExecutor(int corePoolSize,
                                 int maximumPoolSize)
```
    Creates a default ThreadPool, with default values : - keepAlive set to 30 seconds - A default ThreadFactory - All events are accepted
    
    Parameters:
    
    corePoolSize - The initial pool sizePoolSize
    
    maximumPoolSize - The maximum pool size
  - OrderedThreadPoolExecutor
```
public OrderedThreadPoolExecutor(int corePoolSize,
                                 int maximumPoolSize,
                                 long keepAliveTime,
                                 java.util.concurrent.TimeUnit unit)
```
    Creates a default ThreadPool, with default values : - A default ThreadFactory - All events are accepted
    
    Parameters:
    
    corePoolSize - The initial pool sizePoolSize
    
    maximumPoolSize - The maximum pool size
    
    keepAliveTime - Default duration for a thread
    
    unit - Time unit used for the keepAlive value
  - OrderedThreadPoolExecutor
```
public OrderedThreadPoolExecutor(int corePoolSize,
                                 int maximumPoolSize,
                                 long keepAliveTime,
                                 java.util.concurrent.TimeUnit unit,
                                 IoEventQueueHandler eventQueueHandler)
```
    Creates a default ThreadPool, with default values : - A default ThreadFactory
    
    Parameters:
    
    corePoolSize - The initial pool sizePoolSize
    
    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
  - OrderedThreadPoolExecutor
```
public OrderedThreadPoolExecutor(int corePoolSize,
                                 int maximumPoolSize,
                                 long keepAliveTime,
                                 java.util.concurrent.TimeUnit unit,
                                 java.util.concurrent.ThreadFactory threadFactory)
```
    Creates a default ThreadPool, with default values : - A default ThreadFactory
    
    Parameters:
    
    corePoolSize - 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
  - OrderedThreadPoolExecutor
```
public OrderedThreadPoolExecutor(int corePoolSize,
                                 int maximumPoolSize,
                                 long keepAliveTime,
                                 java.util.concurrent.TimeUnit unit,
                                 java.util.concurrent.ThreadFactory threadFactory,
                                 IoEventQueueHandler eventQueueHandler)
```
    Creates a new instance of a OrderedThreadPoolExecutor.
    
    Parameters:
    
    corePoolSize - 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
- Method Detail
  - getSessionTasksQueue
```
private OrderedThreadPoolExecutor.SessionTasksQueue 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 corePoolSize)
```
    Overrides:
    
    setCorePoolSize in class java.util.concurrent.ThreadPoolExecutor

Class OrderedThreadPoolExecutor

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

DEFAULT_INITIAL_THREAD_POOL_SIZE

DEFAULT_MAX_THREAD_POOL

DEFAULT_KEEP_ALIVE

EXIT_SIGNAL

TASKS_QUEUE

waitingSessions

workers

largestPoolSize

idleWorkers

completedTaskCount

shutdown

eventQueueHandler

Constructor Detail

OrderedThreadPoolExecutor

OrderedThreadPoolExecutor

OrderedThreadPoolExecutor

OrderedThreadPoolExecutor

OrderedThreadPoolExecutor

OrderedThreadPoolExecutor

OrderedThreadPoolExecutor

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