Multiplexed, non-blocking I/O, which is much more scalable than
thread-oriented, blocking I/O, is provided by selectors, selectable
channels, and selection keys.
A selector is a multiplexor of selectable channels, which in turn are
a special type of channel that can be put into non-blocking mode. To perform
multiplexed I/O operations, one or more selectable channels are first created,
put into non-blocking mode, and
registered
with a selector. Registering a channel specifies the set of I/O operations
that will be tested for readiness by the selector, and returns a selection key that represents the
registration.
Once some channels have been registered with a selector, a selection operation can be performed in
order to discover which channels, if any, have become ready to perform one or
more of the operations in which interest was previously declared. If a channel
is ready then the key returned when it was registered will be added to the
selector's selected-key set. The key set, and the keys within it, can
be examined in order to determine the operations for which each channel is
ready. From each key one can retrieve the corresponding channel in order to
perform whatever I/O operations are required.
That a selection key indicates that its channel is ready for some operation
is a hint, but not a guarantee, that such an operation can be performed by a
thread without causing the thread to block. It is imperative that code that
performs multiplexed I/O be written so as to ignore these hints when they prove
to be incorrect.
This package defines selectable-channel classes corresponding to the DatagramSocket
, ServerSocket
, and Socket
classes defined in the java.net
package.
Minor changes to these classes have been made in order to support sockets that
are associated with channels. This package also defines a simple class that
implements unidirectional pipes. In all cases, a new selectable channel is
created by invoking the static open method of the corresponding class.
If a channel needs an associated socket then a socket will be created as a side
effect of this operation.
The implementation of selectors, selectable channels, and selection keys
can be replaced by "plugging in" an alternative definition or instance of the
SelectorProvider
class defined in the java.nio.channels.spi
package. It is not expected that many developers
will actually make use of this facility; it is provided primarily so that
sophisticated users can take advantage of operating-system-specific
I/O-multiplexing mechanisms when very high performance is required.
Much of the bookkeeping and synchronization required to implement the
multiplexed-I/O abstractions is performed by the AbstractInterruptibleChannel
, AbstractSelectableChannel
, AbstractSelectionKey
, and AbstractSelector
classes in the java.nio.channels.spi
package. When defining a custom selector provider,
only the AbstractSelector
and AbstractSelectionKey
classes should be subclassed
directly; custom channel classes should extend the appropriate SelectableChannel
subclasses defined in this package.
Unless otherwise noted, passing a null argument to a constructor
or method in any class or interface in this package will cause a NullPointerException
to be thrown.