org.apache.mina.core.service

## Class SimpleIoProcessorPool<S extends AbstractIoSession>

- 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 Object
      implements IoProcessor<S>

  An `IoProcessor` pool that distributes `IoSession`s into one or more `IoProcessor`s. 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 `IoService`s in the same JVM.

  If you are running multiple `IoService`s, 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();

  Author:
    Apache MINA Project

- - ### Constructor Summary

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

  - ### Method Summary

    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`.
    `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`

- - ### Constructor Detail

    - #### SimpleIoProcessorPool

          public SimpleIoProcessorPool(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(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(Class<? extends IoProcessor<S>> processorType,
                               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(Class<? extends IoProcessor<S>> processorType,
                               Executor executor,
                               int size)

      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>`

Copyright © 2004-2012 Apache MINA Project. All Rights Reserved.