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

    Constructors
    Constructor and Description
    `AbstractIOReactor(long selectTimeout)` Creates new AbstractIOReactor instance.
    `AbstractIOReactor(long selectTimeout, boolean interestOpsQueueing)` Creates new AbstractIOReactor instance.

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `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.