Class AbstractSelector

java.lang.Object
java.nio.channels.Selector
java.nio.channels.spi.AbstractSelector
All Implemented Interfaces:
Closeable, AutoCloseable

public abstract class AbstractSelector extends Selector
Base implementation class for selectors.

This class encapsulates the low-level machinery required to implement the interruption of selection operations. A concrete selector class must invoke the begin and end methods before and after, respectively, invoking an I/O operation that might block indefinitely. In order to ensure that the end method is always invoked, these methods should be used within a try ... finally block:

    try {
        begin();
        // Perform blocking I/O operation here
        ...
    } finally {
        end();
    }

This class also defines methods for maintaining a selector's cancelled-key set and for removing a key from its channel's key set, and declares the abstract register method that is invoked by a selectable channel's register method in order to perform the actual work of registering a channel.

Since:
1.4
  • Constructor Summary

    Constructors
    Modifier
    Constructor
    Description
    protected
    Initializes a new instance of this class.
  • Method Summary

    Modifier and Type
    Method
    Description
    protected final void
    Marks the beginning of an I/O operation that might block indefinitely.
    protected final Set<SelectionKey>
    Retrieves this selector's cancelled-key set.
    final void
    Closes this selector.
    protected final void
    Removes the given key from its channel's key set.
    protected final void
    end()
    Marks the end of an I/O operation that might block indefinitely.
    protected abstract void
    Closes this selector.
    final boolean
    Tells whether or not this selector is open.
    Returns the provider that created this channel.
    protected abstract SelectionKey
    Registers the given channel with this selector.

    Methods declared in class Selector

    keys, open, select, select, select, select, selectedKeys, selectNow, selectNow, wakeup
    Modifier and Type
    Method
    Description
    abstract Set<SelectionKey>
    Returns this selector's key set.
    static Selector
    Opens a selector.
    abstract int
    Selects a set of keys whose corresponding channels are ready for I/O operations.
    abstract int
    select(long timeout)
    Selects a set of keys whose corresponding channels are ready for I/O operations.
    int
    Selects and performs an action on the keys whose corresponding channels are ready for I/O operations.
    int
    select(Consumer<SelectionKey> action, long timeout)
    Selects and performs an action on the keys whose corresponding channels are ready for I/O operations.
    abstract Set<SelectionKey>
    Returns this selector's selected-key set.
    abstract int
    Selects a set of keys whose corresponding channels are ready for I/O operations.
    int
    Selects and performs an action on the keys whose corresponding channels are ready for I/O operations.
    abstract Selector
    Causes the first selection operation that has not yet returned to return immediately.

    Methods declared in class Object

    clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
    Modifier and Type
    Method
    Description
    protected Object
    Creates and returns a copy of this object.
    boolean
    Indicates whether some other object is "equal to" this one.
    protected void
    Deprecated, for removal: This API element is subject to removal in a future version.
    Finalization is deprecated and subject to removal in a future release.
    final Class<?>
    Returns the runtime class of this Object.
    int
    Returns a hash code value for this object.
    final void
    Wakes up a single thread that is waiting on this object's monitor.
    final void
    Wakes up all threads that are waiting on this object's monitor.
    Returns a string representation of the object.
    final void
    Causes the current thread to wait until it is awakened, typically by being notified or interrupted.
    final void
    wait(long timeoutMillis)
    Causes the current thread to wait until it is awakened, typically by being notified or interrupted, or until a certain amount of real time has elapsed.
    final void
    wait(long timeoutMillis, int nanos)
    Causes the current thread to wait until it is awakened, typically by being notified or interrupted, or until a certain amount of real time has elapsed.
  • Constructor Details

    • AbstractSelector

      protected AbstractSelector(SelectorProvider provider)
      Initializes a new instance of this class.
      Parameters:
      provider - The provider that created this selector
  • Method Details

    • close

      public final void close() throws IOException
      Closes this selector.

      If the selector has already been closed then this method returns immediately. Otherwise it marks the selector as closed and then invokes the implCloseSelector method in order to complete the close operation.

      Specified by:
      close in interface AutoCloseable
      Specified by:
      close in interface Closeable
      Specified by:
      close in class Selector
      Throws:
      IOException - If an I/O error occurs
    • implCloseSelector

      protected abstract void implCloseSelector() throws IOException
      Closes this selector.

      This method is invoked by the close method in order to perform the actual work of closing the selector. This method is only invoked if the selector has not yet been closed, and it is never invoked more than once.

      An implementation of this method must arrange for any other thread that is blocked in a selection operation upon this selector to return immediately as if by invoking the wakeup method.

      Throws:
      IOException - If an I/O error occurs while closing the selector
    • isOpen

      public final boolean isOpen()
      Description copied from class: Selector
      Tells whether or not this selector is open.
      Specified by:
      isOpen in class Selector
      Returns:
      true if, and only if, this selector is open
    • provider

      public final SelectorProvider provider()
      Returns the provider that created this channel.
      Specified by:
      provider in class Selector
      Returns:
      The provider that created this channel
    • cancelledKeys

      protected final Set<SelectionKey> cancelledKeys()
      Retrieves this selector's cancelled-key set.

      This set should only be used while synchronized upon it.

      Returns:
      The cancelled-key set
    • register

      protected abstract SelectionKey register(AbstractSelectableChannel ch, int ops, Object att)
      Registers the given channel with this selector.

      This method is invoked by a channel's register method in order to perform the actual work of registering the channel with this selector.

      Parameters:
      ch - The channel to be registered
      ops - The initial interest set, which must be valid
      att - The initial attachment for the resulting key
      Returns:
      A new key representing the registration of the given channel with this selector
    • deregister

      protected final void deregister(AbstractSelectionKey key)
      Removes the given key from its channel's key set.

      This method must be invoked by the selector for each channel that it deregisters.

      Parameters:
      key - The selection key to be removed
    • begin

      protected final void begin()
      Marks the beginning of an I/O operation that might block indefinitely.

      This method should be invoked in tandem with the end method, using a try ... finally block as shown above, in order to implement interruption for this selector.

      Invoking this method arranges for the selector's wakeup method to be invoked if a thread's interrupt method is invoked while the thread is blocked in an I/O operation upon the selector.

    • end

      protected final void end()
      Marks the end of an I/O operation that might block indefinitely.

      This method should be invoked in tandem with the begin method, using a try ... finally block as shown above, in order to implement interruption for this selector.