An asynchronous channel group encapsulates the mechanics required to
handle the completion of I/O operations initiated by asynchronous channels that are bound to the group. A group has an associated
thread pool to which tasks are submitted to handle I/O events and dispatch to
completion-handlers that consume the result of
asynchronous operations performed on channels in the group. In addition to
handling I/O events, the pooled threads may also execute other tasks required
to support the execution of asynchronous I/O operations.
An asynchronous channel group is created by invoking the withFixedThreadPool or withCachedThreadPool methods defined here. Channels are bound to a group by
specifying the group when constructing the channel. The associated thread
pool is owned by the group; termination of the group results in the
shutdown of the associated thread pool.
In addition to groups created explicitly, the Java virtual machine
maintains a system-wide default group that is constructed
automatically. Asynchronous channels that do not specify a group at
construction time are bound to the default group. The default group has an
associated thread pool that creates new threads as needed. The default group
may be configured by means of system properties defined in the table below.
Where the ThreadFactory for the
default group is not configured then the pooled threads of the default group
are daemon threads.
| System property | Description |
|---|---|
java.nio.channels.DefaultThreadPool.threadFactory
|
The value of this property is taken to be the fully-qualified name
of a concrete ThreadFactory
class. The class is loaded using the system class loader and instantiated.
The factory's newThread method is invoked to create each thread for the default
group's thread pool. If the process to load and instantiate the value
of the property fails then an unspecified error is thrown during the
construction of the default group. |
java.nio.channels.DefaultThreadPool.initialSize
|
The value of the initialSize parameter for the default
group (see withCachedThreadPool).
The value of the property is taken to be the String
representation of an Integer that is the initial size parameter.
If the value cannot be parsed as an Integer it causes an
unspecified error to be thrown during the construction of the default
group. |
The completion handler for an I/O operation initiated on a channel bound to a group is guaranteed to be invoked by one of the pooled threads in the group. This ensures that the completion handler is run by a thread with the expected identity.
Where an I/O operation completes immediately, and the initiating thread
is one of the pooled threads in the group then the completion handler may
be invoked directly by the initiating thread. To avoid stack overflow, an
implementation may impose a limit as to the number of activations on the
thread stack. Some I/O operations may prohibit invoking the completion
handler directly by the initiating thread (see accept).
The shutdown method is used to initiate an orderly
shutdown of a group. An orderly shutdown marks the group as shutdown;
further attempts to construct a channel that binds to the group will throw
ShutdownChannelGroupException. Whether or not a group is shutdown can
be tested using the isShutdown method. Once shutdown,
the group terminates when all asynchronous channels that are bound to
the group are closed, all actively executing completion handlers have run to
completion, and resources used by the group are released. No attempt is made
to stop or interrupt threads that are executing completion handlers. The
isTerminated method is used to test if the group has
terminated, and the awaitTermination method can be
used to block until the group has terminated.
The shutdownNow method can be used to initiate a
forceful shutdown of the group. In addition to the actions performed
by an orderly shutdown, the shutdownNow method closes all open channels
in the group as if by invoking the close
method.
AsynchronousSocketChannel#open(AsynchronousChannelGroup), AsynchronousServerSocketChannel#open(AsynchronousChannelGroup)
| Modifier and Type | Field and Description |
|---|---|
| private final AsynchronousChannelProvider |
| Access | Constructor and Description |
|---|---|
| protected | AsynchronousChannelGroup(AsynchronousChannelProvider
The asynchronous channel provider for this group provider)Initialize a new instance of this class. |
| Modifier and Type | Method and Description |
|---|---|
| public abstract boolean | Returns: true if the group has terminated; false if the
timeout elapsed before terminationThe maximum time to wait, or zero or less to not wait timeout, TimeUnit The time unit of the timeout argument unit)Awaits termination of the group. |
| public abstract boolean | Returns: true if this asynchronous channel group is shutdown or
has been marked for shutdown.Tells whether or not this asynchronous channel group is shutdown. |
| public abstract boolean | Returns: true if this group has terminatedTells whether or not this group has terminated. |
| public final AsynchronousChannelProvider | Returns: The provider that created this channel groupReturns the provider that created this channel group. |
| public abstract void | |
| public abstract void | |
| public static AsynchronousChannelGroup | Returns: A new asynchronous channel groupThe thread pool for the resulting group executor, int A value initialSize)>=0 or a negative value for implementation
specific defaultCreates an asynchronous channel group with a given thread pool that creates new threads as needed. |
| public static AsynchronousChannelGroup | Returns: A new asynchronous channel groupThe number of threads in the pool nThreads, ThreadFactory The factory to use when creating new threads threadFactory)Creates an asynchronous channel group with a fixed thread pool. |
| public static AsynchronousChannelGroup | Returns: A new asynchronous channel groupThe thread pool for the resulting group executor)Creates an asynchronous channel group with a given thread pool. |
| provider | back to summary |
|---|---|
| private final AsynchronousChannelProvider provider | |
| AsynchronousChannelGroup | back to summary |
|---|---|
| protected AsynchronousChannelGroup(AsynchronousChannelProvider provider) Initialize a new instance of this class.
| |
| awaitTermination | back to summary |
|---|---|
| public abstract boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException Awaits termination of the group. This method blocks until the group has terminated, or the timeout occurs, or the current thread is interrupted, whichever happens first.
| |
| isShutdown | back to summary |
|---|---|
| public abstract boolean isShutdown() Tells whether or not this asynchronous channel group is shutdown.
| |
| isTerminated | back to summary |
|---|---|
| public abstract boolean isTerminated() Tells whether or not this group has terminated. Where this method returns
| |
| provider | back to summary |
|---|---|
| public final AsynchronousChannelProvider provider() Returns the provider that created this channel group.
| |
| shutdown | back to summary |
|---|---|
| public abstract void shutdown() Initiates an orderly shutdown of the group. This method marks the group as shutdown. Further attempts to construct
channel that binds to this group will throw | |
| shutdownNow | back to summary |
|---|---|
| public abstract void shutdownNow() throws IOException Shuts down the group and closes all open channels in the group. In addition to the actions performed by the
| |
| withCachedThreadPool | back to summary |
|---|---|
| public static AsynchronousChannelGroup withCachedThreadPool(ExecutorService executor, int initialSize) throws IOException Creates an asynchronous channel group with a given thread pool that creates new threads as needed. The The The executor is intended to be used exclusively by the resulting
asynchronous channel group. Termination of the group results in the
orderly The group is created by invoking the
| |
| withFixedThreadPool | back to summary |
|---|---|
| public static AsynchronousChannelGroup withFixedThreadPool(int nThreads, ThreadFactory threadFactory) throws IOException Creates an asynchronous channel group with a fixed thread pool. The resulting asynchronous channel group reuses a fixed number of
threads. At any point, at most The group is created by invoking the
| |
| withThreadPool | back to summary |
|---|---|
| public static AsynchronousChannelGroup withThreadPool(ExecutorService executor) throws IOException Creates an asynchronous channel group with a given thread pool. The Care should be taken when configuring the executor service. It
should support direct handoff or unbounded queuing of
submitted tasks, and the thread that invokes the The executor is intended to be used exclusively by the resulting
asynchronous channel group. Termination of the group results in the
orderly The group is created by invoking the
| |