Some channels may not allow more than one read or write to be outstanding * at any given time. If a thread invokes a read method before a previous read * operation has completed then a {@link ReadPendingException} will be thrown. * Similarly, if a write method is invoked before a previous write has completed * then {@link WritePendingException} is thrown. Whether or not other kinds of * I/O operations may proceed concurrently with a read operation depends upon * the type of the channel. * *
Note that {@link java.nio.ByteBuffer ByteBuffers} are not safe for use by * multiple concurrent threads. When a read or write operation is initiated then * care must be taken to ensure that the buffer is not accessed until the * operation completes. * * @see Channels#newInputStream(AsynchronousByteChannel) * @see Channels#newOutputStream(AsynchronousByteChannel) * * @since 1.7 */ public interface AsynchronousByteChannel extends AsynchronousChannel { /** * Reads a sequence of bytes from this channel into the given buffer. * *
This method initiates an asynchronous read operation to read a * sequence of bytes from this channel into the given buffer. The {@code * handler} parameter is a completion handler that is invoked when the read * operation completes (or fails). The result passed to the completion * handler is the number of bytes read or {@code -1} if no bytes could be * read because the channel has reached end-of-stream. * *
The read operation may read up to r bytes from the channel, * where r is the number of bytes remaining in the buffer, that is, * {@code dst.remaining()} at the time that the read is attempted. Where * r is 0, the read operation completes immediately with a result of * {@code 0} without initiating an I/O operation. * *
Suppose that a byte sequence of length n is read, where * 0 < n <= r. * This byte sequence will be transferred into the buffer so that the first * byte in the sequence is at index p and the last byte is at index * p + n - 1, * where p is the buffer's position at the moment the read is * performed. Upon completion the buffer's position will be equal to * p + n; its limit will not have changed. * *
Buffers are not safe for use by multiple concurrent threads so care * should be taken to not access the buffer until the operation has * completed. * *
This method may be invoked at any time. Some channel types may not
* allow more than one read to be outstanding at any given time. If a thread
* initiates a read operation before a previous read operation has
* completed then a {@link ReadPendingException} will be thrown.
*
* @param
* The type of the attachment
* @param dst
* The buffer into which bytes are to be transferred
* @param attachment
* The object to attach to the I/O operation; can be {@code null}
* @param handler
* The completion handler
*
* @throws IllegalArgumentException
* If the buffer is read-only
* @throws ReadPendingException
* If the channel does not allow more than one read to be outstanding
* and a previous read has not completed
* @throws ShutdownChannelGroupException
* If the channel is associated with a {@link AsynchronousChannelGroup
* group} that has terminated
*/
void read(ByteBuffer dst,
A attachment,
CompletionHandler This method initiates an asynchronous read operation to read a
* sequence of bytes from this channel into the given buffer. The method
* behaves in exactly the same manner as the {@link
* #read(ByteBuffer,Object,CompletionHandler)
* read(ByteBuffer,Object,CompletionHandler)} method except that instead
* of specifying a completion handler, this method returns a {@code Future}
* representing the pending result. The {@code Future}'s {@link Future#get()
* get} method returns the number of bytes read or {@code -1} if no bytes
* could be read because the channel has reached end-of-stream.
*
* @param dst
* The buffer into which bytes are to be transferred
*
* @return A Future representing the result of the operation
*
* @throws IllegalArgumentException
* If the buffer is read-only
* @throws ReadPendingException
* If the channel does not allow more than one read to be outstanding
* and a previous read has not completed
*/
Future This method initiates an asynchronous write operation to write a
* sequence of bytes to this channel from the given buffer. The {@code
* handler} parameter is a completion handler that is invoked when the write
* operation completes (or fails). The result passed to the completion
* handler is the number of bytes written.
*
* The write operation may write up to r bytes to the channel,
* where r is the number of bytes remaining in the buffer, that is,
* {@code src.remaining()} at the time that the write is attempted. Where
* r is 0, the write operation completes immediately with a result of
* {@code 0} without initiating an I/O operation.
*
* Suppose that a byte sequence of length n is written, where
* 0 < n <= r.
* This byte sequence will be transferred from the buffer starting at index
* p, where p is the buffer's position at the moment the
* write is performed; the index of the last byte written will be
* p + n - 1.
* Upon completion the buffer's position will be equal to
* p + n; its limit will not have changed.
*
* Buffers are not safe for use by multiple concurrent threads so care
* should be taken to not access the buffer until the operation has
* completed.
*
* This method may be invoked at any time. Some channel types may not
* allow more than one write to be outstanding at any given time. If a thread
* initiates a write operation before a previous write operation has
* completed then a {@link WritePendingException} will be thrown.
*
* @param
* The type of the attachment
* @param src
* The buffer from which bytes are to be retrieved
* @param attachment
* The object to attach to the I/O operation; can be {@code null}
* @param handler
* The completion handler object
*
* @throws WritePendingException
* If the channel does not allow more than one write to be outstanding
* and a previous write has not completed
* @throws ShutdownChannelGroupException
* If the channel is associated with a {@link AsynchronousChannelGroup
* group} that has terminated
*/
void write(ByteBuffer src,
A attachment,
CompletionHandler This method initiates an asynchronous write operation to write a
* sequence of bytes to this channel from the given buffer. The method
* behaves in exactly the same manner as the {@link
* #write(ByteBuffer,Object,CompletionHandler)
* write(ByteBuffer,Object,CompletionHandler)} method except that instead
* of specifying a completion handler, this method returns a {@code Future}
* representing the pending result. The {@code Future}'s {@link Future#get()
* get} method returns the number of bytes written.
*
* @param src
* The buffer from which bytes are to be retrieved
*
* @return A Future representing the result of the operation
*
* @throws WritePendingException
* If the channel does not allow more than one write to be outstanding
* and a previous write has not completed
*/
Future