## org.apache.http.impl.nio.reactor
Class AbstractIOReactor

    java.lang.Object
      org.apache.http.impl.nio.reactor.AbstractIOReactor

All Implemented Interfaces:
  IOReactor

Direct Known Subclasses:
  BaseIOReactor

    @ThreadSafe
    public abstract class AbstractIOReactor

extends Object
implements IOReactor

Generic implementation of `IOReactor` that can used as a subclass for more specialized I/O reactors. It is based on a single `Selector` instance.

Since:
  4.0

Constructor Summary
`AbstractIOReactor(long selectTimeout)` Creates new AbstractIOReactor instance.
`AbstractIOReactor(long selectTimeout, boolean interestOpsQueueing)` Creates new AbstractIOReactor instance.

Method Summary
`protected abstract void` `acceptable(SelectionKey key)` Triggered when the key signals `SelectionKey.OP_ACCEPT` readiness.
`void` `addChannel(ChannelEntry channelEntry)` Adds new channel entry.
`void` `awaitShutdown(long timeout)` Blocks for the given period of time in milliseconds awaiting the completion of the reactor shutdown.
`protected void` `closeActiveChannels()` Closes out all active channels registered with the selector of this I/O reactor.
`protected void` `closeNewChannels()` Closes out all new channels pending registration with the selector of this I/O reactor.
`protected void` `closeSessions()` Closes out all I/O sessions maintained by this I/O reactor.
`protected abstract void` `connectable(SelectionKey key)` Triggered when the key signals `SelectionKey.OP_CONNECT` readiness.
`protected void` `execute()` Activates the I/O reactor.
`boolean` `getInterestOpsQueueing()` Returns `true` if interest Ops queueing is enabled, `false` otherwise.
`protected IOSession` `getSession(SelectionKey key)` Obtains `IOSession` instance associated with the given selection key.
`IOReactorStatus` `getStatus()` Returns the current status of the reactor.
`void` `gracefulShutdown()` Attempts graceful shutdown of this I/O reactor.
`void` `hardShutdown()` Attempts force-shutdown of this I/O reactor.
`protected void` `processEvent(SelectionKey key)` Processes new event on the given selection key.
`protected void` `queueClosedSession(IOSession session)` Queues the given I/O session to be processed asynchronously as closed.
`protected abstract void` `readable(SelectionKey key)` Triggered when the key signals `SelectionKey.OP_READ` readiness.
`protected void` `sessionClosed(IOSession session)` Triggered when a session has been closed.
`protected void` `sessionCreated(SelectionKey key, IOSession session)` Triggered when new session has been created.
`protected void` `sessionTimedOut(IOSession session)` Triggered when a session has timed out.
`void` `shutdown()` Initiates shutdown of the reactor and blocks for a default period of time waiting for the reactor to terminate all active connections, to shut down itself and to release system resources it currently holds.
`void` `shutdown(long gracePeriod)` Initiates shutdown of the reactor and blocks approximately for the given period of time in milliseconds waiting for the reactor to terminate all active connections, to shut down itself and to release system resources it currently holds.
`protected void` `timeoutCheck(SelectionKey key, long now)` Triggered to verify whether the I/O session associated with the given selection key has not timed out.
`protected abstract void` `validate(Set<SelectionKey> keys)` Triggered to validate keys currently registered with the selector.
`protected abstract void` `writable(SelectionKey key)` Triggered when the key signals `SelectionKey.OP_WRITE` readiness.

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

Methods inherited from interface org.apache.http.nio.reactor.IOReactor
`execute`

Constructor Detail

### AbstractIOReactor

    public AbstractIOReactor(long selectTimeout)
                      throws IOReactorException

  Creates new AbstractIOReactor instance.

  Parameters:
    `selectTimeout` - the select timeout.
  Throws:
    `IOReactorException` - in case if a non-recoverable I/O error.

### AbstractIOReactor

    public AbstractIOReactor(long selectTimeout,
                             boolean interestOpsQueueing)
                      throws IOReactorException

  Creates new AbstractIOReactor instance.

  Parameters:
    `selectTimeout` - the select timeout.
    `interestOpsQueueing` - Ops queueing flag.
  Throws:
    `IOReactorException` - in case if a non-recoverable I/O error.
  Since:
    4.1

Method Detail

### acceptable

    protected abstract void acceptable(SelectionKey key)

  Triggered when the key signals `SelectionKey.OP_ACCEPT` readiness.

  Super-classes can implement this method to react to the event.

  Parameters:
    `key` - the selection key.

### connectable

    protected abstract void connectable(SelectionKey key)

  Triggered when the key signals `SelectionKey.OP_CONNECT` readiness.

  Super-classes can implement this method to react to the event.

  Parameters:
    `key` - the selection key.

### readable

    protected abstract void readable(SelectionKey key)

  Triggered when the key signals `SelectionKey.OP_READ` readiness.

  Super-classes can implement this method to react to the event.

  Parameters:
    `key` - the selection key.

### writable

    protected abstract void writable(SelectionKey key)

  Triggered when the key signals `SelectionKey.OP_WRITE` readiness.

  Super-classes can implement this method to react to the event.

  Parameters:
    `key` - the selection key.

### validate

    protected abstract void validate(Set<SelectionKey> keys)

  Triggered to validate keys currently registered with the selector. This method is called after each I/O select loop.

  Super-classes can implement this method to run validity checks on active sessions and include additional processing that needs to be executed after each I/O select loop.

  Parameters:
    `keys` - all selection keys registered with the selector.

### sessionCreated

    protected void sessionCreated(SelectionKey key,
                                  IOSession session)

  Triggered when new session has been created.

  Super-classes can implement this method to react to the event.

  Parameters:
    `key` - the selection key.
    `session` - new I/O session.

### sessionClosed

    protected void sessionClosed(IOSession session)

  Triggered when a session has been closed.

  Super-classes can implement this method to react to the event.

  Parameters:
    `session` - closed I/O session.

### sessionTimedOut

    protected void sessionTimedOut(IOSession session)

  Triggered when a session has timed out.

  Super-classes can implement this method to react to the event.

  Parameters:
    `session` - timed out I/O session.

### getSession

    protected IOSession getSession(SelectionKey key)

  Obtains `IOSession` instance associated with the given selection key.

  Parameters:
    `key` - the selection key.
  Returns:
    I/O session.

### getStatus

    public IOReactorStatus getStatus()

  Description copied from interface: `IOReactor`
  Returns the current status of the reactor.

  Specified by:
    `getStatus` in interface `IOReactor`
  Returns:
    reactor status.

### getInterestOpsQueueing

    public boolean getInterestOpsQueueing()

  Returns `true` if interest Ops queueing is enabled, `false` otherwise.

  Since:
    4.1

### addChannel

    public void addChannel(ChannelEntry channelEntry)

  Adds new channel entry. The channel will be asynchronously registered with the selector.

  Parameters:
    `channelEntry` - the channel entry.

### execute

    protected void execute()
                    throws InterruptedIOException,
                           IOReactorException

  Activates the I/O reactor. The I/O reactor will start reacting to I/O events and triggering notification methods.

  This method will enter the infinite I/O select loop on the `Selector` instance associated with this I/O reactor.

  The method will remain blocked unto the I/O reactor is shut down or the execution thread is interrupted.

  Throws:
    `InterruptedIOException` - if the dispatch thread is interrupted.
    `IOReactorException` - in case if a non-recoverable I/O error.
  See Also:
    `acceptable(SelectionKey)`, `connectable(SelectionKey)`, `readable(SelectionKey)`, `writable(SelectionKey)`, `timeoutCheck(SelectionKey, long)`, `validate(Set)`, `sessionCreated(SelectionKey, IOSession)`, `sessionClosed(IOSession)`

### processEvent

    protected void processEvent(SelectionKey key)

  Processes new event on the given selection key.

  Parameters:
    `key` - the selection key that triggered an event.

### queueClosedSession

    protected void queueClosedSession(IOSession session)

  Queues the given I/O session to be processed asynchronously as closed.

  Parameters:
    `session` - the closed I/O session.

### timeoutCheck

    protected void timeoutCheck(SelectionKey key,
                                long now)

  Triggered to verify whether the I/O session associated with the given selection key has not timed out.

  Super-classes can implement this method to react to the event.

  Parameters:
    `key` - the selection key.
    `now` - current time as long value.

### closeSessions

    protected void closeSessions()

  Closes out all I/O sessions maintained by this I/O reactor.

### closeNewChannels

    protected void closeNewChannels()
                             throws IOReactorException

  Closes out all new channels pending registration with the selector of this I/O reactor.

  Throws:
    `IOReactorException` - - not thrown currently

### closeActiveChannels

    protected void closeActiveChannels()
                                throws IOReactorException

  Closes out all active channels registered with the selector of this I/O reactor.

  Throws:
    `IOReactorException` - - not thrown currently

### gracefulShutdown

    public void gracefulShutdown()

  Attempts graceful shutdown of this I/O reactor.

### hardShutdown

    public void hardShutdown()
                      throws IOReactorException

  Attempts force-shutdown of this I/O reactor.

  Throws:
    `IOReactorException`

### awaitShutdown

    public void awaitShutdown(long timeout)
                       throws InterruptedException

  Blocks for the given period of time in milliseconds awaiting the completion of the reactor shutdown.

  Parameters:
    `timeout` - the maximum wait time.
  Throws:
    `InterruptedException` - if interrupted.

### shutdown

    public void shutdown(long gracePeriod)
                  throws IOReactorException

  Description copied from interface: `IOReactor`
  Initiates shutdown of the reactor and blocks approximately for the given period of time in milliseconds waiting for the reactor to terminate all active connections, to shut down itself and to release system resources it currently holds.

  Specified by:
    `shutdown` in interface `IOReactor`
  Parameters:
    `gracePeriod` - wait time in milliseconds.
  Throws:
    `IOReactorException`

### shutdown

    public void shutdown()
                  throws IOReactorException

  Description copied from interface: `IOReactor`
  Initiates shutdown of the reactor and blocks for a default period of time waiting for the reactor to terminate all active connections, to shut down itself and to release system resources it currently holds. It is up to individual implementations to decide for how long this method can remain blocked.

  Specified by:
    `shutdown` in interface `IOReactor`
  Throws:
    `IOReactorException`

Copyright © 2005-2013 The Apache Software Foundation. All Rights Reserved.