SimpleIoProcessorPool

java.lang.Object
- org.apache.mina.core.service.SimpleIoProcessorPool<S>

Type Parameters:

S - the type of the IoSession to be managed by the specified IoProcessor.

All Implemented Interfaces:

IoProcessor<S>
```
public class SimpleIoProcessorPool<S extends AbstractIoSession>
extends java.lang.Object
implements IoProcessor<S>
```
An IoProcessor pool that distributes IoSessions into one or more IoProcessors. Most current transport implementations use this pool internally to perform better in a multi-core environment, and therefore, you won't need to use this pool directly unless you are running multiple IoServices in the same JVM.
If you are running multiple IoServices, you could want to share the pool among all services. To do so, you can create a new SimpleIoProcessorPool instance by yourself and provide the pool as a constructor parameter when you create the services.
This pool uses Java reflection API to create multiple IoProcessor instances. It tries to instantiate the processor in the following order:
1. A public constructor with one ExecutorService parameter.
2. A public constructor with one Executor parameter.
3. A public default constructor
The following is an example for the NIO socket transport:
```
 // Create a shared pool.
 SimpleIoProcessorPool<NioSession> pool = 
         new SimpleIoProcessorPool<NioSession>(NioProcessor.class, 16);
 
 // Create two services that share the same pool.
 SocketAcceptor acceptor = new NioSocketAcceptor(pool);
 SocketConnector connector = new NioSocketConnector(pool);
 
 ...
 
 // Release related resources.
 connector.dispose();
 acceptor.dispose();
 pool.dispose();
 
```

Field Summary

Fields
Modifier and Type	Field and Description
`private boolean`	`createdExecutor` A flag set to true if we had to create an executor
`private static int`	`DEFAULT_SIZE` The default pool size, when no size is provided.
`private java.lang.Object`	`disposalLock` A lock to protect the disposal against concurrent calls
`private boolean`	`disposed` A flag set to true if all the IoProcessor contained in the pool have been disposed
`private boolean`	`disposing` A flg set to true if the IoProcessor in the pool are being disposed
`private java.util.concurrent.Executor`	`executor` The contained which is passed to the IoProcessor when they are created
`private static org.slf4j.Logger`	`LOGGER` A logger for this class
`private IoProcessor<S>[]`	`pool` The pool table
`private static AttributeKey`	`PROCESSOR` A key used to store the processor pool in the session's Attributes

Constructor Summary

Constructors
Constructor and Description
`SimpleIoProcessorPool(java.lang.Class<? extends IoProcessor<S>> processorType)` Creates a new instance of SimpleIoProcessorPool with a default size of NbCPUs +1.
`SimpleIoProcessorPool(java.lang.Class<? extends IoProcessor<S>> processorType, java.util.concurrent.Executor executor)` Creates a new instance of SimpleIoProcessorPool with an executor
`SimpleIoProcessorPool(java.lang.Class<? extends IoProcessor<S>> processorType, java.util.concurrent.Executor executor, int size, java.nio.channels.spi.SelectorProvider selectorProvider)` Creates a new instance of SimpleIoProcessorPool with an executor
`SimpleIoProcessorPool(java.lang.Class<? extends IoProcessor<S>> processorType, int size)` Creates a new instance of SimpleIoProcessorPool with a defined number of IoProcessors in the pool
`SimpleIoProcessorPool(java.lang.Class<? extends IoProcessor<S>> processorType, int size, java.nio.channels.spi.SelectorProvider selectorProvider)` Creates a new instance of SimpleIoProcessorPool with a defined number of IoProcessors in the pool

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`add(S session)` Adds the specified `session` to the I/O processor so that the I/O processor starts to perform any I/O operations related with the `session`.
`void`	`dispose()` Releases any resources allocated by this processor.
`void`	`flush(S session)` Flushes the internal write request queue of the specified `session`.
`private IoProcessor<S>`	`getProcessor(S session)` Find the processor associated to a session.
`boolean`	`isDisposed()` Returns `true` if and if only all resources of this processor have been disposed.
`boolean`	`isDisposing()` Returns `true` if and if only `IoProcessor.dispose()` method has been called.
`void`	`remove(S session)` Removes and closes the specified `session` from the I/O processor so that the I/O processor closes the connection associated with the `session` and releases any other related resources.
`void`	`updateTrafficControl(S session)` Controls the traffic of the specified `session` depending of the `IoSession.isReadSuspended()` and `IoSession.isWriteSuspended()` flags
`void`	`write(S session, WriteRequest writeRequest)` Writes the WriteRequest for the specified `session`.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - LOGGER
```
private static final org.slf4j.Logger LOGGER
```
    A logger for this class
  - DEFAULT_SIZE
```
private static final int DEFAULT_SIZE
```
    The default pool size, when no size is provided.
  - PROCESSOR
```
private static final AttributeKey PROCESSOR
```
    A key used to store the processor pool in the session's Attributes
  - pool
```
private final IoProcessor<S extends AbstractIoSession>[] pool
```
    The pool table
  - executor
```
private final java.util.concurrent.Executor executor
```
    The contained which is passed to the IoProcessor when they are created
  - createdExecutor
```
private final boolean createdExecutor
```
    A flag set to true if we had to create an executor
  - disposalLock
```
private final java.lang.Object disposalLock
```
    A lock to protect the disposal against concurrent calls
  - disposing
```
private volatile boolean disposing
```
    A flg set to true if the IoProcessor in the pool are being disposed
  - disposed
```
private volatile boolean disposed
```
    A flag set to true if all the IoProcessor contained in the pool have been disposed
- Constructor Detail
  - SimpleIoProcessorPool
```
public SimpleIoProcessorPool(java.lang.Class<? extends IoProcessor<S>> processorType)
```
    Creates a new instance of SimpleIoProcessorPool with a default size of NbCPUs +1.
    
    Parameters:
    
    processorType - The type of IoProcessor to use
  - SimpleIoProcessorPool
```
public SimpleIoProcessorPool(java.lang.Class<? extends IoProcessor<S>> processorType,
                             int size)
```
    Creates a new instance of SimpleIoProcessorPool with a defined number of IoProcessors in the pool
    
    Parameters:
    
    processorType - The type of IoProcessor to use
    
    size - The number of IoProcessor in the pool
  - SimpleIoProcessorPool
```
public SimpleIoProcessorPool(java.lang.Class<? extends IoProcessor<S>> processorType,
                             int size,
                             java.nio.channels.spi.SelectorProvider selectorProvider)
```
    Creates a new instance of SimpleIoProcessorPool with a defined number of IoProcessors in the pool
    
    Parameters:
    
    processorType - The type of IoProcessor to use
    
    size - The number of IoProcessor in the pool
    
    selectorProvider - The SelectorProvider to use
  - SimpleIoProcessorPool
```
public SimpleIoProcessorPool(java.lang.Class<? extends IoProcessor<S>> processorType,
                             java.util.concurrent.Executor executor)
```
    Creates a new instance of SimpleIoProcessorPool with an executor
    
    Parameters:
    
    processorType - The type of IoProcessor to use
    
    executor - The Executor
  - SimpleIoProcessorPool
```
public SimpleIoProcessorPool(java.lang.Class<? extends IoProcessor<S>> processorType,
                             java.util.concurrent.Executor executor,
                             int size,
                             java.nio.channels.spi.SelectorProvider selectorProvider)
```
    Creates a new instance of SimpleIoProcessorPool with an executor
    
    Parameters:
    
    processorType - The type of IoProcessor to use
    
    executor - The Executor
    
    size - The number of IoProcessor in the pool
- Method Detail
  - add
```
public final void add(S session)
```
    Adds the specified session to the I/O processor so that the I/O processor starts to perform any I/O operations related with the session.
    
    Specified by:
    
    add in interface IoProcessor<S extends AbstractIoSession>
    
    Parameters:
    
    session - The added session
  - flush
```
public final void flush(S session)
```
    Flushes the internal write request queue of the specified session.
    
    Specified by:
    
    flush in interface IoProcessor<S extends AbstractIoSession>
    
    Parameters:
    
    session - The session we want the message to be written
  - write
```
public final void write(S session,
                        WriteRequest writeRequest)
```
    Writes the WriteRequest for the specified session.
    
    Specified by:
    
    write in interface IoProcessor<S extends AbstractIoSession>
    
    Parameters:
    
    session - The session we want the message to be written
    
    writeRequest - the WriteRequest to write
  - remove
```
public final void remove(S session)
```
    Removes and closes the specified session from the I/O processor so that the I/O processor closes the connection associated with the session and releases any other related resources.
    
    Specified by:
    
    remove in interface IoProcessor<S extends AbstractIoSession>
  - updateTrafficControl
```
public final void updateTrafficControl(S session)
```
    Controls the traffic of the specified session depending of the IoSession.isReadSuspended() and IoSession.isWriteSuspended() flags
    
    Specified by:
    
    updateTrafficControl in interface IoProcessor<S extends AbstractIoSession>
  - isDisposed
```
public boolean isDisposed()
```
    Returns true if and if only all resources of this processor have been disposed.
    
    Specified by:
    
    isDisposed in interface IoProcessor<S extends AbstractIoSession>
  - isDisposing
```
public boolean isDisposing()
```
    Returns true if and if only IoProcessor.dispose() method has been called. Please note that this method will return true even after all the related resources are released.
    
    Specified by:
    
    isDisposing in interface IoProcessor<S extends AbstractIoSession>
  - dispose
```
public final void dispose()
```
    Releases any resources allocated by this processor. Please note that the resources might not be released as long as there are any sessions managed by this processor. Most implementations will close all sessions immediately and release the related resources.
    
    Specified by:
    
    dispose in interface IoProcessor<S extends AbstractIoSession>
  - getProcessor
```
private IoProcessor<S> getProcessor(S session)
```
    Find the processor associated to a session. If it hasen't be stored into the session's attributes, pick a new processor and stores it.

Class SimpleIoProcessorPool<S extends AbstractIoSession>

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

LOGGER

DEFAULT_SIZE

PROCESSOR

pool

executor

createdExecutor

disposalLock

disposing

disposed

Constructor Detail

SimpleIoProcessorPool

SimpleIoProcessorPool

SimpleIoProcessorPool

SimpleIoProcessorPool

SimpleIoProcessorPool

Method Detail

add

flush

write

remove

updateTrafficControl

isDisposed

isDisposing

dispose

getProcessor