OpenJDK 1.23 · sun.nio.ch.AsynchronousFileChannelImpl

Modifier and Type	Field and Description
protected volatile boolean	closed
protected final ReadWriteLock	closeLock
protected final ExecutorService	executor
protected final FileDescriptor	fdObj
private volatile FileLockTable	fileLockTable
protected final boolean	reading
protected final boolean	writing

Access	Constructor and Description
protected	AsynchronousFileChannelImpl(FileDescriptor fdObj, boolean reading, boolean writing, ExecutorService executor)

Method Summary

Modifier and Type	Method and Description
protected final FileLockImpl	addToFileLockTable(long position, long size, boolean shared) Adds region to lock table
protected final void	begin() Marks the beginning of an I/O operation.
protected final void	end() Marks the end of an I/O operation.
protected final void	end(boolean completed) Marks end of I/O operation
pack-priv final void	ensureFileLockTableInitialized()
pack-priv final ExecutorService	executor()
pack-priv abstract <A> Future<FileLock>	implLock(long position, long size, boolean shared, A attachment, CompletionHandler<FileLock, ? super A> handler)
pack-priv abstract <A> Future<Integer>	implRead(ByteBuffer dst, long position, A attachment, CompletionHandler<Integer, ? super A> handler)
protected abstract void	implRelease(FileLockImpl fli) Releases the given file lock.
pack-priv abstract <A> Future<Integer>	implWrite(ByteBuffer src, long position, A attachment, CompletionHandler<Integer, ? super A> handler)
pack-priv final void	invalidateAllLocks()
public final boolean	isOpen() Implements java.nio.channels.Channel.isOpen. Tells whether or not this channel is open.
public final Future<FileLock>	lock(long The position at which the locked region is to start; must be non-negative position, long The size of the locked region; must be non-negative, and the sum `position` + `size` must be non-negative. A value of zero means to lock all bytes from the specified starting position to the end of the file, regardless of whether the file is subsequently extended or truncated size, boolean `true` to request a shared lock, in which case this channel must be open for reading (and possibly writing); `false` to request an exclusive lock, in which case this channel must be open for writing (and possibly reading) shared) Implements abstract java.nio.channels.AsynchronousFileChannel.lock. Acquires a lock on the given region of this channel's file.
public final <A> void	lock(long The position at which the locked region is to start; must be non-negative position, long The size of the locked region; must be non-negative, and the sum `position` + `size` must be non-negative. A value of zero means to lock all bytes from the specified starting position to the end of the file, regardless of whether the file is subsequently extended or truncated size, boolean `true` to request a shared lock, in which case this channel must be open for reading (and possibly writing); `false` to request an exclusive lock, in which case this channel must be open for writing (and possibly reading) shared, A The object to attach to the I/O operation; can be `null` attachment, CompletionHandler<FileLock, ? super A> The handler for consuming the result handler) Implements abstract java.nio.channels.AsynchronousFileChannel.lock. Acquires a lock on the given region of this channel's file.
public final Future<Integer>	read(ByteBuffer The buffer into which bytes are to be transferred dst, long The file position at which the transfer is to begin; must be non-negative position) Implements abstract java.nio.channels.AsynchronousFileChannel.read. Reads a sequence of bytes from this channel into the given buffer, starting at the given file position.
public final <A> void	read(ByteBuffer The buffer into which bytes are to be transferred dst, long The file position at which the transfer is to begin; must be non-negative position, A The object to attach to the I/O operation; can be `null` attachment, CompletionHandler<Integer, ? super A> The handler for consuming the result handler) Implements abstract java.nio.channels.AsynchronousFileChannel.read. Reads a sequence of bytes from this channel into the given buffer, starting at the given file position.
pack-priv final void	release(FileLockImpl fli) Invoked by FileLockImpl to release the given file lock and remove it from the lock table.
protected final void	removeFromFileLockTable(FileLockImpl fli)
public final Future<Integer>	write(ByteBuffer The buffer from which bytes are to be transferred src, long The file position at which the transfer is to begin; must be non-negative position) Implements abstract java.nio.channels.AsynchronousFileChannel.write. Writes a sequence of bytes to this channel from the given buffer, starting at the given file position.
public final <A> void	write(ByteBuffer The buffer from which bytes are to be transferred src, long The file position at which the transfer is to begin; must be non-negative position, A The object to attach to the I/O operation; can be `null` attachment, CompletionHandler<Integer, ? super A> The handler for consuming the result handler) Implements abstract java.nio.channels.AsynchronousFileChannel.write. Writes a sequence of bytes to this channel from the given buffer, starting at the given file position.

Inherited from java.nio.channels.AsynchronousFileChannel:: force lock lock open open size truncate tryLock tryLock

closed	back to summary
protected volatile boolean closed

closeLock	back to summary
protected final ReadWriteLock closeLock

executor	back to summary
protected final ExecutorService executor

fdObj	back to summary
protected final FileDescriptor fdObj

fileLockTable	back to summary
private volatile FileLockTable fileLockTable

reading	back to summary
protected final boolean reading

writing	back to summary
protected final boolean writing

AsynchronousFileChannelImpl	back to summary
protected AsynchronousFileChannelImpl(FileDescriptor fdObj, boolean reading, boolean writing, ExecutorService executor)

Method Detail

addToFileLockTable	back to summary
protected final FileLockImpl addToFileLockTable(long position, long size, boolean shared) Adds region to lock table

begin	back to summary
protected final void begin() throws IOException Marks the beginning of an I/O operation. Exceptions ClosedChannelException: If channel is closed

begin

back to summary

protected final void begin() throws IOException

Marks the beginning of an I/O operation.

Exceptions

ClosedChannelException:: If channel is closed

end	back to summary
protected final void end() Marks the end of an I/O operation.

end	back to summary
protected final void end(boolean completed) throws IOException Marks end of I/O operation

ensureFileLockTableInitialized	back to summary
pack-priv final void ensureFileLockTableInitialized() throws IOException

executor	back to summary
pack-priv final ExecutorService executor()

implLock	back to summary
pack-priv abstract <A> Future<FileLock> implLock(long position, long size, boolean shared, A attachment, CompletionHandler<FileLock, ? super A> handler)

implRead	back to summary
pack-priv abstract <A> Future<Integer> implRead(ByteBuffer dst, long position, A attachment, CompletionHandler<Integer, ? super A> handler)

implRelease	back to summary
protected abstract void implRelease(FileLockImpl fli) throws IOException Releases the given file lock.

implWrite	back to summary
pack-priv abstract <A> Future<Integer> implWrite(ByteBuffer src, long position, A attachment, CompletionHandler<Integer, ? super A> handler)

invalidateAllLocks	back to summary
pack-priv final void invalidateAllLocks() throws IOException

isOpen back to summary

isOpen	back to summary
public final boolean isOpen() Implements java.nio.channels.Channel.isOpen. Doc from java.nio.channels.Channel.isOpen. Tells whether or not this channel is open. Returns:boolean `true` if, and only if, this channel is open Annotations @Override

public final boolean isOpen()

Implements java.nio.channels.Channel.isOpen.

Doc from java.nio.channels.Channel.isOpen.

Tells whether or not this channel is open.

Returns:boolean

true if, and only if, this channel is open

Annotations

@Override

lock back to summary

lock	back to summary
public final Future<FileLock> lock(long position, long size, boolean shared) Implements abstract java.nio.channels.AsynchronousFileChannel.lock. Doc from java.nio.channels.AsynchronousFileChannel.lock. Acquires a lock on the given region of this channel's file. This method initiates an operation to acquire a lock on the given region of this channel's file. The method behaves in exactly the same manner as the `lock(long, long, boolean, Object, CompletionHandler)` method except that instead of specifying a completion handler, this method returns a `Future` representing the pending result. The `Future`'s `get` method returns the `FileLock` on successful completion. Parameters position:long The position at which the locked region is to start; must be non-negative size:long The size of the locked region; must be non-negative, and the sum `position` + `size` must be non-negative. A value of zero means to lock all bytes from the specified starting position to the end of the file, regardless of whether the file is subsequently extended or truncated shared:boolean `true` to request a shared lock, in which case this channel must be open for reading (and possibly writing); `false` to request an exclusive lock, in which case this channel must be open for writing (and possibly reading) Returns:Future<FileLock> a `Future` object representing the pending result Annotations @Override

public final Future<FileLock> lock(long position, long size, boolean shared)

Implements abstract java.nio.channels.AsynchronousFileChannel.lock.

Doc from java.nio.channels.AsynchronousFileChannel.lock.

Acquires a lock on the given region of this channel's file.

This method initiates an operation to acquire a lock on the given region of this channel's file. The method behaves in exactly the same manner as the lock(long, long, boolean, Object, CompletionHandler) method except that instead of specifying a completion handler, this method returns a Future representing the pending result. The Future's get method returns the FileLock on successful completion.

Parameters

position:long: The position at which the locked region is to start; must be non-negative
size:long: The size of the locked region; must be non-negative, and the sum position + size must be non-negative. A value of zero means to lock all bytes from the specified starting position to the end of the file, regardless of whether the file is subsequently extended or truncated
shared:boolean: true to request a shared lock, in which case this channel must be open for reading (and possibly writing); false to request an exclusive lock, in which case this channel must be open for writing (and possibly reading)

Returns:Future<FileLock>

a Future object representing the pending result

Annotations

@Override

lock back to summary

lock	back to summary
public final <A> void lock(long position, long size, boolean shared, A attachment, CompletionHandler<FileLock, ? super A> handler) Implements abstract java.nio.channels.AsynchronousFileChannel.lock. Doc from java.nio.channels.AsynchronousFileChannel.lock. Acquires a lock on the given region of this channel's file. This method initiates an operation to acquire a lock on the given region of this channel's file. The `handler` parameter is a completion handler that is invoked when the lock is acquired (or the operation fails). The result passed to the completion handler is the resulting `FileLock`. The region specified by the `position` and `size` parameters need not be contained within, or even overlap, the actual underlying file. Lock regions are fixed in size; if a locked region initially contains the end of the file and the file grows beyond the region then the new portion of the file will not be covered by the lock. If a file is expected to grow in size and a lock on the entire file is required then a region starting at zero, and no smaller than the expected maximum size of the file, should be locked. The two-argument `lock(Object, CompletionHandler)` method simply locks a region of size `Long#MAX_VALUE`. If the `position` is non-negative and the `size` is zero, then a lock of size `Long.MAX_VALUE - position` is returned. If a lock that overlaps the requested region is already held by this Java virtual machine, or this method has been invoked to lock an overlapping region and that operation has not completed, then this method throws `OverlappingFileLockException`. Some operating systems do not support a mechanism to acquire a file lock in an asynchronous manner. Consequently an implementation may acquire the file lock in a background thread or from a task executed by a thread in the associated thread pool. If there are many lock operations outstanding then it may consume threads in the Java virtual machine for indefinite periods. Some operating systems do not support shared locks, in which case a request for a shared lock is automatically converted into a request for an exclusive lock. Whether the newly-acquired lock is shared or exclusive may be tested by invoking the resulting lock object's `isShared` method. File locks are held on behalf of the entire Java virtual machine. They are not suitable for controlling access to a file by multiple threads within the same virtual machine. Parameters <A> The type of the attachment position:long The position at which the locked region is to start; must be non-negative size:long The size of the locked region; must be non-negative, and the sum `position` + `size` must be non-negative. A value of zero means to lock all bytes from the specified starting position to the end of the file, regardless of whether the file is subsequently extended or truncated shared:boolean `true` to request a shared lock, in which case this channel must be open for reading (and possibly writing); `false` to request an exclusive lock, in which case this channel must be open for writing (and possibly reading) attachment:A The object to attach to the I/O operation; can be `null` handler:CompletionHandler<FileLock, ? super A> The handler for consuming the result Annotations @Override

public final <A> void lock(long position, long size, boolean shared, A attachment, CompletionHandler<FileLock, ? super A> handler)

Implements abstract java.nio.channels.AsynchronousFileChannel.lock.

Doc from java.nio.channels.AsynchronousFileChannel.lock.

Acquires a lock on the given region of this channel's file.

This method initiates an operation to acquire a lock on the given region of this channel's file. The handler parameter is a completion handler that is invoked when the lock is acquired (or the operation fails). The result passed to the completion handler is the resulting FileLock.

The region specified by the position and size parameters need not be contained within, or even overlap, the actual underlying file. Lock regions are fixed in size; if a locked region initially contains the end of the file and the file grows beyond the region then the new portion of the file will not be covered by the lock. If a file is expected to grow in size and a lock on the entire file is required then a region starting at zero, and no smaller than the expected maximum size of the file, should be locked. The two-argument lock(Object, CompletionHandler) method simply locks a region of size Long#MAX_VALUE. If the position is non-negative and the size is zero, then a lock of size Long.MAX_VALUE - position is returned. If a lock that overlaps the requested region is already held by this Java virtual machine, or this method has been invoked to lock an overlapping region and that operation has not completed, then this method throws OverlappingFileLockException.

Some operating systems do not support a mechanism to acquire a file lock in an asynchronous manner. Consequently an implementation may acquire the file lock in a background thread or from a task executed by a thread in the associated thread pool. If there are many lock operations outstanding then it may consume threads in the Java virtual machine for indefinite periods.

Some operating systems do not support shared locks, in which case a request for a shared lock is automatically converted into a request for an exclusive lock. Whether the newly-acquired lock is shared or exclusive may be tested by invoking the resulting lock object's isShared method.

File locks are held on behalf of the entire Java virtual machine. They are not suitable for controlling access to a file by multiple threads within the same virtual machine.

Parameters

<A>: The type of the attachment
position:long: The position at which the locked region is to start; must be non-negative
size:long: The size of the locked region; must be non-negative, and the sum position + size must be non-negative. A value of zero means to lock all bytes from the specified starting position to the end of the file, regardless of whether the file is subsequently extended or truncated
shared:boolean: true to request a shared lock, in which case this channel must be open for reading (and possibly writing); false to request an exclusive lock, in which case this channel must be open for writing (and possibly reading)
attachment:A: The object to attach to the I/O operation; can be null
handler:CompletionHandler<FileLock, ? super A>: The handler for consuming the result

Annotations

@Override

read back to summary

read	back to summary
public final Future<Integer> read(ByteBuffer dst, long position) Implements abstract java.nio.channels.AsynchronousFileChannel.read. Doc from java.nio.channels.AsynchronousFileChannel.read. Reads a sequence of bytes from this channel into the given buffer, starting at the given file position. This method initiates the reading of a sequence of bytes from this channel into the given buffer, starting at the given file position. This method returns a `Future` representing the pending result of the operation. The `Future`'s `get` method returns the number of bytes read or `-1` if the given position is greater than or equal to the file's size at the time that the read is attempted. This method works in the same manner as the `AsynchronousByteChannel#read(ByteBuffer)` method, except that bytes are read starting at the given file position. If the given file position is greater than the file's size at the time that the read is attempted then no bytes are read. Parameters dst:ByteBuffer The buffer into which bytes are to be transferred position:long The file position at which the transfer is to begin; must be non-negative Returns:Future<Integer> A `Future` object representing the pending result Annotations @Override

public final Future<Integer> read(ByteBuffer dst, long position)

Implements abstract java.nio.channels.AsynchronousFileChannel.read.

Doc from java.nio.channels.AsynchronousFileChannel.read.

Reads a sequence of bytes from this channel into the given buffer, starting at the given file position.

This method initiates the reading of a sequence of bytes from this channel into the given buffer, starting at the given file position. This method returns a Future representing the pending result of the operation. The Future's get method returns the number of bytes read or -1 if the given position is greater than or equal to the file's size at the time that the read is attempted.

This method works in the same manner as the AsynchronousByteChannel#read(ByteBuffer) method, except that bytes are read starting at the given file position. If the given file position is greater than the file's size at the time that the read is attempted then no bytes are read.

Parameters

dst:ByteBuffer: The buffer into which bytes are to be transferred
position:long: The file position at which the transfer is to begin; must be non-negative

Returns:Future<Integer>

A Future object representing the pending result

Annotations

@Override

read back to summary

read	back to summary
public final <A> void read(ByteBuffer dst, long position, A attachment, CompletionHandler<Integer, ? super A> handler) Implements abstract java.nio.channels.AsynchronousFileChannel.read. Doc from java.nio.channels.AsynchronousFileChannel.read. Reads a sequence of bytes from this channel into the given buffer, starting at the given file position. This method initiates the reading of a sequence of bytes from this channel into the given buffer, starting at the given file position. The result of the read is the number of bytes read or `-1` if the given position is greater than or equal to the file's size at the time that the read is attempted. This method works in the same manner as the `AsynchronousByteChannel#read(ByteBuffer, Object, CompletionHandler)` method, except that bytes are read starting at the given file position. If the given file position is greater than the file's size at the time that the read is attempted then no bytes are read. Parameters <A> The type of the attachment dst:ByteBuffer The buffer into which bytes are to be transferred position:long The file position at which the transfer is to begin; must be non-negative attachment:A The object to attach to the I/O operation; can be `null` handler:CompletionHandler<Integer, ? super A> The handler for consuming the result Annotations @Override

public final <A> void read(ByteBuffer dst, long position, A attachment, CompletionHandler<Integer, ? super A> handler)

Implements abstract java.nio.channels.AsynchronousFileChannel.read.

Doc from java.nio.channels.AsynchronousFileChannel.read.

Reads a sequence of bytes from this channel into the given buffer, starting at the given file position.

This method initiates the reading of a sequence of bytes from this channel into the given buffer, starting at the given file position. The result of the read is the number of bytes read or -1 if the given position is greater than or equal to the file's size at the time that the read is attempted.

This method works in the same manner as the AsynchronousByteChannel#read(ByteBuffer, Object, CompletionHandler) method, except that bytes are read starting at the given file position. If the given file position is greater than the file's size at the time that the read is attempted then no bytes are read.

Parameters

<A>: The type of the attachment
dst:ByteBuffer: The buffer into which bytes are to be transferred
position:long: The file position at which the transfer is to begin; must be non-negative
attachment:A: The object to attach to the I/O operation; can be null
handler:CompletionHandler<Integer, ? super A>: The handler for consuming the result

Annotations

@Override

release	back to summary
pack-priv final void release(FileLockImpl fli) throws IOException Invoked by FileLockImpl to release the given file lock and remove it from the lock table.

removeFromFileLockTable	back to summary
protected final void removeFromFileLockTable(FileLockImpl fli)

write back to summary

write	back to summary
public final Future<Integer> write(ByteBuffer src, long position) Implements abstract java.nio.channels.AsynchronousFileChannel.write. Doc from java.nio.channels.AsynchronousFileChannel.write. Writes a sequence of bytes to this channel from the given buffer, starting at the given file position. This method initiates the writing of a sequence of bytes to this channel from the given buffer, starting at the given file position. The method returns a `Future` representing the pending result of the write operation. The `Future`'s `get` method returns the number of bytes written. This method works in the same manner as the `AsynchronousByteChannel#write(ByteBuffer)` method, except that bytes are written starting at the given file position. If the given position is greater than the file's size, at the time that the write is attempted, then the file will be grown to accommodate the new bytes; the values of any bytes between the previous end-of-file and the newly-written bytes are unspecified. Parameters src:ByteBuffer The buffer from which bytes are to be transferred position:long The file position at which the transfer is to begin; must be non-negative Returns:Future<Integer> A `Future` object representing the pending result Annotations @Override

public final Future<Integer> write(ByteBuffer src, long position)

Implements abstract java.nio.channels.AsynchronousFileChannel.write.

Doc from java.nio.channels.AsynchronousFileChannel.write.

Writes a sequence of bytes to this channel from the given buffer, starting at the given file position.

This method initiates the writing of a sequence of bytes to this channel from the given buffer, starting at the given file position. The method returns a Future representing the pending result of the write operation. The Future's get method returns the number of bytes written.

This method works in the same manner as the AsynchronousByteChannel#write(ByteBuffer) method, except that bytes are written starting at the given file position. If the given position is greater than the file's size, at the time that the write is attempted, then the file will be grown to accommodate the new bytes; the values of any bytes between the previous end-of-file and the newly-written bytes are unspecified.

Parameters

src:ByteBuffer: The buffer from which bytes are to be transferred
position:long: The file position at which the transfer is to begin; must be non-negative

Returns:Future<Integer>

A Future object representing the pending result

Annotations

@Override

write back to summary

write	back to summary
public final <A> void write(ByteBuffer src, long position, A attachment, CompletionHandler<Integer, ? super A> handler) Implements abstract java.nio.channels.AsynchronousFileChannel.write. Doc from java.nio.channels.AsynchronousFileChannel.write. Writes a sequence of bytes to this channel from the given buffer, starting at the given file position. This method works in the same manner as the `AsynchronousByteChannel#write(ByteBuffer, Object, CompletionHandler)` method, except that bytes are written starting at the given file position. If the given position is greater than the file's size, at the time that the write is attempted, then the file will be grown to accommodate the new bytes; the values of any bytes between the previous end-of-file and the newly-written bytes are unspecified. Parameters <A> The type of the attachment src:ByteBuffer The buffer from which bytes are to be transferred position:long The file position at which the transfer is to begin; must be non-negative attachment:A The object to attach to the I/O operation; can be `null` handler:CompletionHandler<Integer, ? super A> The handler for consuming the result Annotations @Override

public final <A> void write(ByteBuffer src, long position, A attachment, CompletionHandler<Integer, ? super A> handler)

Implements abstract java.nio.channels.AsynchronousFileChannel.write.

Doc from java.nio.channels.AsynchronousFileChannel.write.

Writes a sequence of bytes to this channel from the given buffer, starting at the given file position.

This method works in the same manner as the AsynchronousByteChannel#write(ByteBuffer, Object, CompletionHandler) method, except that bytes are written starting at the given file position. If the given position is greater than the file's size, at the time that the write is attempted, then the file will be grown to accommodate the new bytes; the values of any bytes between the previous end-of-file and the newly-written bytes are unspecified.

Parameters

<A>: The type of the attachment
src:ByteBuffer: The buffer from which bytes are to be transferred
position:long: The file position at which the transfer is to begin; must be non-negative
attachment:A: The object to attach to the I/O operation; can be null
handler:CompletionHandler<Integer, ? super A>: The handler for consuming the result

Annotations

@Override

pack-priv abstract Class AsynchronousFileChannelImpl

Field Summary

Constructor Summary

Method Summary

Field Detail

Constructor Detail

Method Detail