AbstractPollingIoProcessor

java.lang.Object
- org.apache.mina.core.polling.AbstractPollingIoProcessor<S>

Type Parameters:

S - the type of the IoSession this processor can handle

All Implemented Interfaces:

IoProcessor<S>

Direct Known Subclasses:

NioProcessor
```
public abstract class AbstractPollingIoProcessor<S extends AbstractIoSession>
extends java.lang.Object
implements IoProcessor<S>
```
An abstract implementation of IoProcessor which helps transport developers to write an IoProcessor easily. This class is in charge of active polling a set of IoSession and trigger events when some I/O operation is possible.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

private class AbstractPollingIoProcessor.Processor
The main loop.

Nested Classes
Modifier and Type	Class and Description
`private class`	`AbstractPollingIoProcessor.Processor` The main loop.

Field Summary

Fields
Modifier and Type	Field and Description
`private DefaultIoFuture`	`disposalFuture`
`private java.lang.Object`	`disposalLock`
`private boolean`	`disposed`
`private boolean`	`disposing`
`private java.util.concurrent.Executor`	`executor` The executor to use when we need to start the inner Processor
`private java.util.Queue<S>`	`flushingSessions` A queue used to store the sessions to be flushed
`private long`	`lastIdleCheckTime`
`private static org.slf4j.Logger`	`LOG` A logger for this class
`private java.util.Queue<S>`	`newSessions` A Session queue containing the newly created sessions
`private java.util.concurrent.atomic.AtomicReference<AbstractPollingIoProcessor.Processor>`	`processorRef` The processor thread : it handles the incoming messages
`private java.util.Queue<S>`	`removingSessions` A queue used to store the sessions to be removed
`private static long`	`SELECT_TIMEOUT` A timeout used for the select, as we need to get out to deal with idle sessions
`private static java.util.concurrent.ConcurrentHashMap<java.lang.Class<?>,java.util.concurrent.atomic.AtomicInteger>`	`threadIds` A map containing the last Thread ID for each class
`private java.lang.String`	`threadName` This IoProcessor instance name
`private java.util.Queue<S>`	`trafficControllingSessions` A queue used to store the sessions which have a trafficControl to be updated
`protected java.util.concurrent.atomic.AtomicBoolean`	`wakeupCalled`
`private static int`	`WRITE_SPIN_COUNT` The maximum loop count for a write operation until `write(AbstractIoSession, IoBuffer, int)` returns non-zero value.

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`AbstractPollingIoProcessor(java.util.concurrent.Executor executor)` Create an `AbstractPollingIoProcessor` with the given `Executor` for handling I/Os events.

Method Summary

All Methods Instance Methods Abstract 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`.
`private boolean`	`addNow(S session)` Process a new session : - initialize it - create its chain - fire the CREATED listeners if any
`protected abstract java.util.Iterator<S>`	`allSessions()` Get an `Iterator` for the list of `IoSession` polled by this `IoProcessor`
`private void`	`clearWriteRequestQueue(S session)`
`protected abstract void`	`destroy(S session)` Destroy the underlying client socket handle
`void`	`dispose()` Releases any resources allocated by this processor.
`protected abstract void`	`doDispose()` Dispose the resources used by this `IoProcessor` for polling the client connections.
`private void`	`fireMessageSent(S session, WriteRequest req)`
`private void`	`flush(long currentTime)` Write all the pending messages
`void`	`flush(S session)` Flushes the internal write request queue of the specified `session`.
`private boolean`	`flushNow(S session, long currentTime)`
`protected abstract SessionState`	`getState(S session)` Get the state of a session (preparing, open, closed)
`private int`	`handleNewSessions()` Loops over the new sessions blocking queue and returns the number of sessions which are effectively created
`protected abstract void`	`init(S session)` Initialize the polling of a session.
`protected abstract boolean`	`isBrokenConnection()` Check that the select() has not exited immediately just because of a broken connection.
`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.
`protected abstract boolean`	`isInterestedInRead(S session)` is this session registered for reading
`protected abstract boolean`	`isInterestedInWrite(S session)` is this session registered for writing
`protected abstract boolean`	`isReadable(S session)` Is the session ready for reading
`protected abstract boolean`	`isSelectorEmpty()` Say if the list of `IoSession` polled by this `IoProcessor` is empty
`protected abstract boolean`	`isWritable(S session)` Is the session ready for writing
`private java.lang.String`	`nextThreadName()` Compute the thread ID for this class instance.
`private void`	`notifyIdleSessions(long currentTime)`
`private void`	`process()`
`private void`	`process(S session)` Deal with session ready for the read or write operations, or both.
`private void`	`read(S session)`
`protected abstract int`	`read(S session, IoBuffer buf)` Reads a sequence of bytes from a `IoSession` into the given `IoBuffer`.
`protected abstract void`	`registerNewSelector()` In the case we are using the java select() method, this method is used to trash the buggy selector and create a new one, registring all the sockets on it.
`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.
`private boolean`	`removeNow(S session)`
`private int`	`removeSessions()`
`private void`	`scheduleFlush(S session)`
`private void`	`scheduleRemove(S session)`
`protected abstract int`	`select()` poll those sessions forever
`protected abstract int`	`select(long timeout)` poll those sessions for the given timeout
`protected abstract java.util.Iterator<S>`	`selectedSessions()` Get an `Iterator` for the list of `IoSession` found selected by the last call of `select(long)`
`protected abstract void`	`setInterestedInRead(S session, boolean isInterested)` register a session for reading
`protected abstract void`	`setInterestedInWrite(S session, boolean isInterested)` register a session for writing
`private void`	`startupProcessor()` Starts the inner Processor, asking the executor to pick a thread in its pool.
`protected abstract int`	`transferFile(S session, FileRegion region, int length)` Write a part of a file to a `IoSession`, if the underlying API isn't supporting system calls like sendfile(), you can throw a `UnsupportedOperationException` so the file will be send using usual `write(AbstractIoSession, IoBuffer, int)` call.
`void`	`updateTrafficControl(S session)` Controls the traffic of the specified `session` depending of the `IoSession.isReadSuspended()` and `IoSession.isWriteSuspended()` flags
`private void`	`updateTrafficMask()` Update the trafficControl for all the session.
`void`	`updateTrafficMask(S session)` Updates the traffic mask for a given session
`protected abstract void`	`wakeup()` Interrupt the `select(long)` call.
`protected abstract int`	`write(S session, IoBuffer buf, int length)` Write a sequence of bytes to a `IoSession`, means to be called when a session was found ready for writing.
`void`	`write(S session, WriteRequest writeRequest)` Writes the WriteRequest for the specified `session`.
`private int`	`writeBuffer(S session, WriteRequest req, boolean hasFragmentation, int maxLength, long currentTime)`
`private int`	`writeFile(S session, WriteRequest req, boolean hasFragmentation, int maxLength, long currentTime)`

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

- Field Detail
  - LOG
```
private static final org.slf4j.Logger LOG
```
    A logger for this class
  - WRITE_SPIN_COUNT
```
private static final int WRITE_SPIN_COUNT
```
    The maximum loop count for a write operation until write(AbstractIoSession, IoBuffer, int) returns non-zero value. It is similar to what a spin lock is for in concurrency programming. It improves memory utilization and write throughput significantly.
    
    See Also:
    
    Constant Field Values
  - SELECT_TIMEOUT
```
private static final long SELECT_TIMEOUT
```
    A timeout used for the select, as we need to get out to deal with idle sessions
    
    See Also:
    
    Constant Field Values
  - threadIds
```
private static final java.util.concurrent.ConcurrentHashMap<java.lang.Class<?>,java.util.concurrent.atomic.AtomicInteger> threadIds
```
    A map containing the last Thread ID for each class
  - threadName
```
private final java.lang.String threadName
```
    This IoProcessor instance name
  - executor
```
private final java.util.concurrent.Executor executor
```
    The executor to use when we need to start the inner Processor
  - newSessions
```
private final java.util.Queue<S extends AbstractIoSession> newSessions
```
    A Session queue containing the newly created sessions
  - removingSessions
```
private final java.util.Queue<S extends AbstractIoSession> removingSessions
```
    A queue used to store the sessions to be removed
  - flushingSessions
```
private final java.util.Queue<S extends AbstractIoSession> flushingSessions
```
    A queue used to store the sessions to be flushed
  - trafficControllingSessions
```
private final java.util.Queue<S extends AbstractIoSession> trafficControllingSessions
```
    A queue used to store the sessions which have a trafficControl to be updated
  - processorRef
```
private final java.util.concurrent.atomic.AtomicReference<AbstractPollingIoProcessor.Processor> processorRef
```
    The processor thread : it handles the incoming messages
  - lastIdleCheckTime
```
private long lastIdleCheckTime
```
  - disposalLock
```
private final java.lang.Object disposalLock
```
  - disposing
```
private volatile boolean disposing
```
  - disposed
```
private volatile boolean disposed
```
  - disposalFuture
```
private final DefaultIoFuture disposalFuture
```
  - wakeupCalled
```
protected java.util.concurrent.atomic.AtomicBoolean wakeupCalled
```
- Constructor Detail
  - AbstractPollingIoProcessor
```
protected AbstractPollingIoProcessor(java.util.concurrent.Executor executor)
```
    Create an AbstractPollingIoProcessor with the given Executor for handling I/Os events.
    
    Parameters:
    
    executor - the Executor for handling I/O events
- Method Detail
  - nextThreadName
```
private java.lang.String nextThreadName()
```
    Compute the thread ID for this class instance. As we may have different classes, we store the last ID number into a Map associating the class name to the last assigned ID.
    
    Returns:
    
    a name for the current thread, based on the class name and an incremental value, starting at 1.
  - isDisposing
```
public final 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>
  - isDisposed
```
public final 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>
  - 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>
  - doDispose
```
protected abstract void doDispose()
                           throws java.lang.Exception
```
    Dispose the resources used by this IoProcessor for polling the client connections. The implementing class doDispose method will be called.
    
    Throws:
    
    java.lang.Exception - if some low level IO error occurs
  - select
```
protected abstract int select(long timeout)
                       throws java.lang.Exception
```
    poll those sessions for the given timeout
    
    Parameters:
    
    timeout - milliseconds before the call timeout if no event appear
    
    Returns:
    
    The number of session ready for read or for write
    
    Throws:
    
    java.lang.Exception - if some low level IO error occurs
  - select
```
protected abstract int select()
                       throws java.lang.Exception
```
    poll those sessions forever
    
    Returns:
    
    The number of session ready for read or for write
    
    Throws:
    
    java.lang.Exception - if some low level IO error occurs
  - isSelectorEmpty
```
protected abstract boolean isSelectorEmpty()
```
    Say if the list of IoSession polled by this IoProcessor is empty
    
    Returns:
    
    true if at least a session is managed by this IoProcessor
  - wakeup
```
protected abstract void wakeup()
```
    Interrupt the select(long) call.
  - allSessions
```
protected abstract java.util.Iterator<S> allSessions()
```
    Get an Iterator for the list of IoSession polled by this IoProcessor
    
    Returns:
    
    Iterator of IoSession
  - selectedSessions
```
protected abstract java.util.Iterator<S> selectedSessions()
```
    Get an Iterator for the list of IoSession found selected by the last call of select(long)
    
    Returns:
    
    Iterator of IoSession read for I/Os operation
  - getState
```
protected abstract SessionState getState(S session)
```
    Get the state of a session (preparing, open, closed)
    
    Parameters:
    
    session - the IoSession to inspect
    
    Returns:
    
    the state of the session
  - isWritable
```
protected abstract boolean isWritable(S session)
```
    Is the session ready for writing
    
    Parameters:
    
    session - the session queried
    
    Returns:
    
    true is ready, false if not ready
  - isReadable
```
protected abstract boolean isReadable(S session)
```
    Is the session ready for reading
    
    Parameters:
    
    session - the session queried
    
    Returns:
    
    true is ready, false if not ready
  - setInterestedInWrite
```
protected abstract void setInterestedInWrite(S session,
                                             boolean isInterested)
                                      throws java.lang.Exception
```
    register a session for writing
    
    Parameters:
    
    session - the session registered
    
    isInterested - true for registering, false for removing
    
    Throws:
    
    java.lang.Exception
  - setInterestedInRead
```
protected abstract void setInterestedInRead(S session,
                                            boolean isInterested)
                                     throws java.lang.Exception
```
    register a session for reading
    
    Parameters:
    
    session - the session registered
    
    isInterested - true for registering, false for removing
    
    Throws:
    
    java.lang.Exception
  - isInterestedInRead
```
protected abstract boolean isInterestedInRead(S session)
```
    is this session registered for reading
    
    Parameters:
    
    session - the session queried
    
    Returns:
    
    true is registered for reading
  - isInterestedInWrite
```
protected abstract boolean isInterestedInWrite(S session)
```
    is this session registered for writing
    
    Parameters:
    
    session - the session queried
    
    Returns:
    
    true is registered for writing
  - init
```
protected abstract void init(S session)
                      throws java.lang.Exception
```
    Initialize the polling of a session. Add it to the polling process.
    
    Parameters:
    
    session - the IoSession to add to the polling
    
    Throws:
    
    java.lang.Exception - any exception thrown by the underlying system calls
  - destroy
```
protected abstract void destroy(S session)
                         throws java.lang.Exception
```
    Destroy the underlying client socket handle
    
    Parameters:
    
    session - the IoSession
    
    Throws:
    
    java.lang.Exception - any exception thrown by the underlying system calls
  - read
```
protected abstract int read(S session,
                            IoBuffer buf)
                     throws java.lang.Exception
```
    Reads a sequence of bytes from a IoSession into the given IoBuffer. Is called when the session was found ready for reading.
    
    Parameters:
    
    session - the session to read
    
    buf - the buffer to fill
    
    Returns:
    
    the number of bytes read
    
    Throws:
    
    java.lang.Exception - any exception thrown by the underlying system calls
  - write
```
protected abstract int write(S session,
                             IoBuffer buf,
                             int length)
                      throws java.lang.Exception
```
    Write a sequence of bytes to a IoSession, means to be called when a session was found ready for writing.
    
    Parameters:
    
    session - the session to write
    
    buf - the buffer to write
    
    length - the number of bytes to write can be superior to the number of bytes remaining in the buffer
    
    Returns:
    
    the number of byte written
    
    Throws:
    
    java.lang.Exception - any exception thrown by the underlying system calls
  - transferFile
```
protected abstract int transferFile(S session,
                                    FileRegion region,
                                    int length)
                             throws java.lang.Exception
```
    Write a part of a file to a IoSession, if the underlying API isn't supporting system calls like sendfile(), you can throw a UnsupportedOperationException so the file will be send using usual write(AbstractIoSession, IoBuffer, int) call.
    
    Parameters:
    
    session - the session to write
    
    region - the file region to write
    
    length - the length of the portion to send
    
    Returns:
    
    the number of written bytes
    
    Throws:
    
    java.lang.Exception - any exception thrown by the underlying system calls
  - 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
  - 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>
  - scheduleRemove
```
private void scheduleRemove(S session)
```
  - write
```
public 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
  - 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
  - scheduleFlush
```
private void scheduleFlush(S session)
```
  - updateTrafficMask
```
public final void updateTrafficMask(S session)
```
    Updates the traffic mask for a given session
    
    Parameters:
    
    session - the session to update
  - startupProcessor
```
private void startupProcessor()
```
    Starts the inner Processor, asking the executor to pick a thread in its pool. The Runnable will be renamed
  - registerNewSelector
```
protected abstract void registerNewSelector()
                                     throws java.io.IOException
```
    In the case we are using the java select() method, this method is used to trash the buggy selector and create a new one, registring all the sockets on it.
    
    Throws:
    
    java.io.IOException - If we got an exception
  - isBrokenConnection
```
protected abstract boolean isBrokenConnection()
                                       throws java.io.IOException
```
    Check that the select() has not exited immediately just because of a broken connection. In this case, this is a standard case, and we just have to loop.
    
    Returns:
    
    true if a connection has been brutally closed.
    
    Throws:
    
    java.io.IOException - If we got an exception
  - handleNewSessions
```
private int handleNewSessions()
```
    Loops over the new sessions blocking queue and returns the number of sessions which are effectively created
    
    Returns:
    
    The number of new sessions
  - addNow
```
private boolean addNow(S session)
```
    Process a new session : - initialize it - create its chain - fire the CREATED listeners if any
    
    Parameters:
    
    session - The session to create
    
    Returns:
    
    true if the session has been registered
  - removeSessions
```
private int removeSessions()
```
  - removeNow
```
private boolean removeNow(S session)
```
  - clearWriteRequestQueue
```
private void clearWriteRequestQueue(S session)
```
  - process
```
private void process()
              throws java.lang.Exception
```
    Throws:
    
    java.lang.Exception
  - process
```
private void process(S session)
```
    Deal with session ready for the read or write operations, or both.
  - read
```
private void read(S session)
```
  - notifyIdleSessions
```
private void notifyIdleSessions(long currentTime)
                         throws java.lang.Exception
```
    Throws:
    
    java.lang.Exception
  - flush
```
private void flush(long currentTime)
```
    Write all the pending messages
  - flushNow
```
private boolean flushNow(S session,
                         long currentTime)
```
  - writeBuffer
```
private int writeBuffer(S session,
                        WriteRequest req,
                        boolean hasFragmentation,
                        int maxLength,
                        long currentTime)
                 throws java.lang.Exception
```
    Throws:
    
    java.lang.Exception
  - writeFile
```
private int writeFile(S session,
                      WriteRequest req,
                      boolean hasFragmentation,
                      int maxLength,
                      long currentTime)
               throws java.lang.Exception
```
    Throws:
    
    java.lang.Exception
  - fireMessageSent
```
private void fireMessageSent(S session,
                             WriteRequest req)
```
  - updateTrafficMask
```
private void updateTrafficMask()
```
    Update the trafficControl for all the session.
  - updateTrafficControl
```
public 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>

Class AbstractPollingIoProcessor<S extends AbstractIoSession>

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

LOG

WRITE_SPIN_COUNT

SELECT_TIMEOUT

threadIds

threadName

executor

newSessions

removingSessions

flushingSessions

trafficControllingSessions

processorRef

lastIdleCheckTime

disposalLock

disposing

disposed

disposalFuture

wakeupCalled

Constructor Detail

AbstractPollingIoProcessor

Method Detail

nextThreadName

isDisposing

isDisposed

dispose

doDispose

select

select

isSelectorEmpty

wakeup

allSessions

selectedSessions

getState

isWritable

isReadable

setInterestedInWrite

setInterestedInRead

isInterestedInRead

isInterestedInWrite

init

destroy

read

write

transferFile

add

remove

scheduleRemove

write

flush

scheduleFlush

updateTrafficMask

startupProcessor

registerNewSelector

isBrokenConnection

handleNewSessions

addNow

removeSessions

removeNow

clearWriteRequestQueue

process

process

read

notifyIdleSessions

flush

flushNow

writeBuffer

writeFile

fireMessageSent

updateTrafficMask

updateTrafficControl