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

All Implemented Interfaces:

java.util.concurrent.Executor, java.util.concurrent.ExecutorService
```
public class UnorderedThreadPoolExecutor
extends java.util.concurrent.ThreadPoolExecutor
```
A ThreadPoolExecutor that does not maintain the order of IoEvents. This means more than one event handler methods can be invoked at the same time with mixed order. For example, let's assume that messageReceived, messageSent, and sessionClosed events are fired.
- All event handler methods can be called simultaneously. (e.g. messageReceived and messageSent can be invoked at the same time.)
- The event order can be mixed up. (e.g. sessionClosed or messageSent can be invoked before messageReceived is invoked.)
If you need to maintain the order of events per session, please use OrderedThreadPoolExecutor.

Nested Class Summary

Nested Classes
Modifier and Type Class Description

private class UnorderedThreadPoolExecutor.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 int`	`corePoolSize`
`private static java.lang.Runnable`	`EXIT_SIGNAL`
`private java.util.concurrent.atomic.AtomicInteger`	`idleWorkers`
`private int`	`largestPoolSize`
`private int`	`maximumPoolSize`
`private IoEventQueueHandler`	`queueHandler`
`private boolean`	`shutdown`
`private java.util.Set<UnorderedThreadPoolExecutor.Worker>`	`workers`

Constructor Summary

Constructors
Constructor	Description
`UnorderedThreadPoolExecutor()`	Creates a new UnorderedThreadPoolExecutor instance
`UnorderedThreadPoolExecutor(int maximumPoolSize)`	Creates a new UnorderedThreadPoolExecutor instance
`UnorderedThreadPoolExecutor(int corePoolSize, int maximumPoolSize)`	Creates a new UnorderedThreadPoolExecutor instance
`UnorderedThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, java.util.concurrent.TimeUnit unit)`	Creates a new UnorderedThreadPoolExecutor instance
`UnorderedThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, java.util.concurrent.TimeUnit unit, java.util.concurrent.ThreadFactory threadFactory)`	Creates a new UnorderedThreadPoolExecutor instance
`UnorderedThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, java.util.concurrent.TimeUnit unit, java.util.concurrent.ThreadFactory threadFactory, IoEventQueueHandler queueHandler)`	Creates a new UnorderedThreadPoolExecutor instance
`UnorderedThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, java.util.concurrent.TimeUnit unit, IoEventQueueHandler queueHandler)`	Creates a new UnorderedThreadPoolExecutor instance

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`private void`	`addWorker()`
`private void`	`addWorkerIfNecessary()`
`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`	`getCorePoolSize()`
`int`	`getLargestPoolSize()`
`int`	`getMaximumPoolSize()`
`int`	`getPoolSize()`
`IoEventQueueHandler`	`getQueueHandler()`
`long`	`getTaskCount()`
`boolean`	`isShutdown()`
`boolean`	`isTerminated()`
`boolean`	`isTerminating()`
`int`	`prestartAllCoreThreads()`
`boolean`	`prestartCoreThread()`
`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, getKeepAliveTime, getQueue, 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
  - EXIT_SIGNAL
```
private static final java.lang.Runnable EXIT_SIGNAL
```
  - workers
```
private final java.util.Set<UnorderedThreadPoolExecutor.Worker> workers
```
  - corePoolSize
```
private volatile int corePoolSize
```
  - maximumPoolSize
```
private volatile int maximumPoolSize
```
  - largestPoolSize
```
private volatile int largestPoolSize
```
  - idleWorkers
```
private final java.util.concurrent.atomic.AtomicInteger idleWorkers
```
  - completedTaskCount
```
private long completedTaskCount
```
  - shutdown
```
private volatile boolean shutdown
```
  - queueHandler
```
private final IoEventQueueHandler queueHandler
```
- Constructor Detail
  - UnorderedThreadPoolExecutor
```
public UnorderedThreadPoolExecutor()
```
    Creates a new UnorderedThreadPoolExecutor instance
  - UnorderedThreadPoolExecutor
```
public UnorderedThreadPoolExecutor(int maximumPoolSize)
```
    Creates a new UnorderedThreadPoolExecutor instance
    
    Parameters:
    
    maximumPoolSize - The maximum number of threads in the pool
  - UnorderedThreadPoolExecutor
```
public UnorderedThreadPoolExecutor(int corePoolSize,
                                   int maximumPoolSize)
```
    Creates a new UnorderedThreadPoolExecutor instance
    
    Parameters:
    
    corePoolSize - The initial threads pool size
    
    maximumPoolSize - The maximum number of threads in the pool
  - UnorderedThreadPoolExecutor
```
public UnorderedThreadPoolExecutor(int corePoolSize,
                                   int maximumPoolSize,
                                   long keepAliveTime,
                                   java.util.concurrent.TimeUnit unit)
```
    Creates a new UnorderedThreadPoolExecutor instance
    
    Parameters:
    
    corePoolSize - The initial threads pool size
    
    maximumPoolSize - The maximum number of threads in the pool
    
    keepAliveTime - The time to keep threads alive
    
    unit - The time unit for the keepAliveTime
  - UnorderedThreadPoolExecutor
```
public UnorderedThreadPoolExecutor(int corePoolSize,
                                   int maximumPoolSize,
                                   long keepAliveTime,
                                   java.util.concurrent.TimeUnit unit,
                                   IoEventQueueHandler queueHandler)
```
    Creates a new UnorderedThreadPoolExecutor instance
    
    Parameters:
    
    corePoolSize - The initial threads pool size
    
    maximumPoolSize - The maximum number of threads in the pool
    
    keepAliveTime - The time to keep threads alive
    
    unit - The time unit for the keepAliveTime
    
    queueHandler - The Event queue handler to use
  - UnorderedThreadPoolExecutor
```
public UnorderedThreadPoolExecutor(int corePoolSize,
                                   int maximumPoolSize,
                                   long keepAliveTime,
                                   java.util.concurrent.TimeUnit unit,
                                   java.util.concurrent.ThreadFactory threadFactory)
```
    Creates a new UnorderedThreadPoolExecutor instance
    
    Parameters:
    
    corePoolSize - The initial threads pool size
    
    maximumPoolSize - The maximum number of threads in the pool
    
    keepAliveTime - The time to keep threads alive
    
    unit - The time unit for the keepAliveTime
    
    threadFactory - The Thread factory to use
  - UnorderedThreadPoolExecutor
```
public UnorderedThreadPoolExecutor(int corePoolSize,
                                   int maximumPoolSize,
                                   long keepAliveTime,
                                   java.util.concurrent.TimeUnit unit,
                                   java.util.concurrent.ThreadFactory threadFactory,
                                   IoEventQueueHandler queueHandler)
```
    Creates a new UnorderedThreadPoolExecutor instance
    
    Parameters:
    
    corePoolSize - The initial threads pool size
    
    maximumPoolSize - The maximum number of threads in the pool
    
    keepAliveTime - The time to keep threads alive
    
    unit - The time unit for the keepAliveTime
    
    threadFactory - The Thread factory to use
    
    queueHandler - The Event queue handler to use
- Method Detail
  - getQueueHandler
```
public IoEventQueueHandler getQueueHandler()
```
    Returns:
    
    The Queue handler in use
  - setRejectedExecutionHandler
```
public void setRejectedExecutionHandler(java.util.concurrent.RejectedExecutionHandler handler)
```
    Overrides:
    
    setRejectedExecutionHandler in class java.util.concurrent.ThreadPoolExecutor
  - addWorker
```
private void addWorker()
```
  - addWorkerIfNecessary
```
private void addWorkerIfNecessary()
```
  - removeWorker
```
private void removeWorker()
```
  - getMaximumPoolSize
```
public int getMaximumPoolSize()
```
    Overrides:
    
    getMaximumPoolSize in class java.util.concurrent.ThreadPoolExecutor
  - 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
  - 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
  - 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
  - getCorePoolSize
```
public int getCorePoolSize()
```
    Overrides:
    
    getCorePoolSize in class java.util.concurrent.ThreadPoolExecutor
  - setCorePoolSize
```
public void setCorePoolSize(int corePoolSize)
```
    Overrides:
    
    setCorePoolSize in class java.util.concurrent.ThreadPoolExecutor

Class UnorderedThreadPoolExecutor

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

EXIT_SIGNAL

workers

corePoolSize

maximumPoolSize

largestPoolSize

idleWorkers

completedTaskCount

shutdown

queueHandler

Constructor Detail

UnorderedThreadPoolExecutor

UnorderedThreadPoolExecutor

UnorderedThreadPoolExecutor

UnorderedThreadPoolExecutor

UnorderedThreadPoolExecutor

UnorderedThreadPoolExecutor

UnorderedThreadPoolExecutor

Method Detail

getQueueHandler

setRejectedExecutionHandler

addWorker

addWorkerIfNecessary

removeWorker

getMaximumPoolSize

setMaximumPoolSize

awaitTermination

isShutdown

isTerminated

shutdown

shutdownNow

execute

rejectTask

checkTaskType

getActiveCount

getCompletedTaskCount

getLargestPoolSize

getPoolSize

getTaskCount

isTerminating

prestartAllCoreThreads

prestartCoreThread

purge

remove

getCorePoolSize

setCorePoolSize