| /* | |
| * Copyright (c) 2000, 2024, Oracle and/or its affiliates. All rights reserved. | |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. | |
| * | |
| * This code is free software; you can redistribute it and/or modify it | |
| * under the terms of the GNU General Public License version 2 only, as | |
| * published by the Free Software Foundation. Oracle designates this | |
| * particular file as subject to the "Classpath" exception as provided | |
| * by Oracle in the LICENSE file that accompanied this code. | |
| * | |
| * This code is distributed in the hope that it will be useful, but WITHOUT | |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| * version 2 for more details (a copy is included in the LICENSE file that | |
| * accompanied this code). | |
| * | |
| * You should have received a copy of the GNU General Public License version | |
| * 2 along with this work; if not, write to the Free Software Foundation, | |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| * | |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA | |
| * or visit www.oracle.com if you need additional information or have any | |
| * questions. | |
| */ | |
| package java.nio.channels; | |
| import java.io.IOException; | |
| import java.lang.foreign.Arena; | |
| import java.lang.foreign.MemorySegment; | |
| import java.nio.ByteBuffer; | |
| import java.nio.MappedByteBuffer; | |
| import java.nio.channels.spi.AbstractInterruptibleChannel; | |
| import java.nio.file.FileAlreadyExistsException; | |
| import java.nio.file.OpenOption; | |
| import java.nio.file.Path; | |
| import java.nio.file.StandardOpenOption; | |
| import java.nio.file.attribute.FileAttribute; | |
| import java.nio.file.spi.FileSystemProvider; | |
| import java.util.Set; | |
| import java.util.HashSet; | |
| import java.util.Collections; | |
| import jdk.internal.javac.PreviewFeature; | |
| /** | |
| * A channel for reading, writing, mapping, and manipulating a file. | |
| * | |
| * <p> A file channel is a {@link SeekableByteChannel} that is connected to | |
| * a file. It has a current <i>position</i> within its file which can | |
| * be both {@link #position() <i>queried</i>} and {@link #position(long) | |
| * <i>modified</i>}. The file itself contains a variable-length sequence | |
| * of bytes that can be read and written and whose current {@link #size | |
| * <i>size</i>} can be queried. The size of the file increases | |
| * when bytes are written beyond its current size; the size of the file | |
| * decreases when it is {@link #truncate <i>truncated</i>}. The | |
| * file may also have some associated <i>metadata</i> such as access | |
| * permissions, content type, and last-modification time; this class does not | |
| * define methods for metadata access. | |
| * | |
| * <p> In addition to the familiar read, write, and close operations of byte | |
| * channels, this class defines the following file-specific operations: </p> | |
| * | |
| * <ul> | |
| * | |
| * <li><p> Bytes may be {@link #read(ByteBuffer, long) read} or | |
| * {@link #write(ByteBuffer, long) <i>written</i>} at an absolute | |
| * position in a file in a way that does not affect the channel's current | |
| * position. </p></li> | |
| * | |
| * <li><p> A region of a file may be {@link #map <i>mapped</i>} | |
| * directly into memory; for large files this is often much more efficient | |
| * than invoking the usual {@code read} or {@code write} methods. | |
| * </p></li> | |
| * | |
| * <li><p> Updates made to a file may be {@link #force <i>forced | |
| * out</i>} to the underlying storage device, ensuring that data are not | |
| * lost in the event of a system crash. </p></li> | |
| * | |
| * <li><p> Bytes can be transferred from a file {@link #transferTo <i>to | |
| * some other channel</i>}, and {@link #transferFrom <i>vice | |
| * versa</i>}, in a way that can be optimized by many operating systems | |
| * into a very fast transfer directly to or from the filesystem cache. | |
| * </p></li> | |
| * | |
| * <li><p> A region of a file may be {@link FileLock <i>locked</i>} | |
| * against access by other programs. </p></li> | |
| * | |
| * </ul> | |
| * | |
| * <p> File channels are safe for use by multiple concurrent threads. The | |
| * {@link Channel#close close} method may be invoked at any time, as specified | |
| * by the {@link Channel} interface. Only one operation that involves the | |
| * channel's position or can change its file's size may be in progress at any | |
| * given time; attempts to initiate a second such operation while the first is | |
| * still in progress will block until the first operation completes. Other | |
| * operations, in particular those that take an explicit position, may proceed | |
| * concurrently; whether they in fact do so is dependent upon the underlying | |
| * implementation and is therefore unspecified. | |
| * | |
| * <p> The view of a file provided by an instance of this class is guaranteed | |
| * to be consistent with other views of the same file provided by other | |
| * instances in the same program. The view provided by an instance of this | |
| * class may or may not, however, be consistent with the views seen by other | |
| * concurrently-running programs due to caching performed by the underlying | |
| * operating system and delays induced by network-filesystem protocols. This | |
| * is true regardless of the language in which these other programs are | |
| * written, and whether they are running on the same machine or on some other | |
| * machine. The exact nature of any such inconsistencies are system-dependent | |
| * and are therefore unspecified. | |
| * | |
| * <p> A file channel is created by invoking one of the {@link #open open} | |
| * methods defined by this class. A file channel can also be obtained from an | |
| * existing {@link java.io.FileInputStream#getChannel FileInputStream}, {@link | |
| * java.io.FileOutputStream#getChannel FileOutputStream}, or {@link | |
| * java.io.RandomAccessFile#getChannel RandomAccessFile} object by invoking | |
| * that object's {@code getChannel} method, which returns a file channel that | |
| * is connected to the same underlying file. Where the file channel is obtained | |
| * from an existing stream or random access file then the state of the file | |
| * channel is intimately connected to that of the object whose {@code getChannel} | |
| * method returned the channel. Changing the channel's position, whether | |
| * explicitly or by reading or writing bytes, will change the file position of | |
| * the originating object, and vice versa. Changing the file's length via the | |
| * file channel will change the length seen via the originating object, and vice | |
| * versa. Changing the file's content by writing bytes will change the content | |
| * seen by the originating object, and vice versa. Closing the channel will | |
| * close the originating object. | |
| * | |
| * <a id="open-mode"></a> <p> At various points this class specifies that an | |
| * instance that is "open for reading," "open for writing," or "open for | |
| * reading and writing" is required. A channel obtained via the {@link | |
| * java.io.FileInputStream#getChannel getChannel} method of a {@link | |
| * java.io.FileInputStream} instance will be open for reading. A channel | |
| * obtained via the {@link java.io.FileOutputStream#getChannel getChannel} | |
| * method of a {@link java.io.FileOutputStream} instance will be open for | |
| * writing. Finally, a channel obtained via the {@link | |
| * java.io.RandomAccessFile#getChannel getChannel} method of a {@link | |
| * java.io.RandomAccessFile} instance will be open for reading if the instance | |
| * was created with mode {@code "r"} and will be open for reading and writing | |
| * if the instance was created with mode {@code "rw"}. | |
| * | |
| * <a id="append-mode"></a><p> A file channel that is open for writing may be in | |
| * <i>append mode</i>, for example if it was obtained from a file-output stream | |
| * that was created by invoking the {@link | |
| * java.io.FileOutputStream#FileOutputStream(java.io.File,boolean) | |
| * FileOutputStream(File,boolean)} constructor and passing {@code true} for | |
| * the second parameter. In this mode each invocation of a relative write | |
| * operation first advances the position to the end of the file and then writes | |
| * the requested data. Whether the advancement of the position and the writing | |
| * of the data are done in a single atomic operation is system-dependent and | |
| * therefore unspecified. In this mode the behavior of the method to | |
| * {@linkplain #write(ByteBuffer,long) write at a given position} is also | |
| * system-dependent. | |
| * | |
| * @see java.io.FileInputStream#getChannel() | |
| * @see java.io.FileOutputStream#getChannel() | |
| * @see java.io.RandomAccessFile#getChannel() | |
| * | |
| * @author Mark Reinhold | |
| * @author Mike McCloskey | |
| * @author JSR-51 Expert Group | |
| * @since 1.4 | |
| */ | |
| public abstract class FileChannel | |
| extends AbstractInterruptibleChannel | |
| implements SeekableByteChannel, GatheringByteChannel, ScatteringByteChannel | |
| { | |
| /** | |
| * Initializes a new instance of this class. | |
| */ | |
| protected FileChannel() { } | |
| /** | |
| * Opens or creates a file, returning a file channel to access the file. | |
| * | |
| * <p> The {@code options} parameter determines how the file is opened. | |
| * The {@link StandardOpenOption#READ READ} and {@link StandardOpenOption#WRITE | |
| * WRITE} options determine if the file should be opened for reading and/or | |
| * writing. If neither option (or the {@link StandardOpenOption#APPEND APPEND} | |
| * option) is contained in the array then the file is opened for reading. | |
| * By default reading or writing commences at the beginning of the file. | |
| * | |
| * <p> In the addition to {@code READ} and {@code WRITE}, the following | |
| * options may be present: | |
| * | |
| * <table class="striped"> | |
| * <caption style="display:none">additional options</caption> | |
| * <thead> | |
| * <tr> <th scope="col">Option</th> <th scope="col">Description</th> </tr> | |
| * </thead> | |
| * <tbody> | |
| * <tr> | |
| * <th scope="row"> {@link StandardOpenOption#APPEND APPEND} </th> | |
| * <td> If this option is present then the file is opened for writing and | |
| * each invocation of the channel's {@code write} method first advances | |
| * the position to the end of the file and then writes the requested | |
| * data. Whether the advancement of the position and the writing of the | |
| * data are done in a single atomic operation is system-dependent and | |
| * therefore unspecified. The effect of {@linkplain | |
| * #write(ByteBuffer,long) writing at a given position} with this option | |
| * present is unspecified. This option may not be used in conjunction | |
| * with the {@code READ} or {@code TRUNCATE_EXISTING} options. </td> | |
| * </tr> | |
| * <tr> | |
| * <th scope="row"> {@link StandardOpenOption#TRUNCATE_EXISTING TRUNCATE_EXISTING} </th> | |
| * <td> If this option is present then the existing file is truncated to | |
| * a size of 0 bytes. This option is ignored when the file is opened only | |
| * for reading. </td> | |
| * </tr> | |
| * <tr> | |
| * <th scope="row"> {@link StandardOpenOption#CREATE_NEW CREATE_NEW} </th> | |
| * <td> If this option is present then a new file is created, failing if | |
| * the file already exists. When creating a file the check for the | |
| * existence of the file and the creation of the file if it does not exist | |
| * is atomic with respect to other file system operations. This option is | |
| * ignored when the file is opened only for reading. </td> | |
| * </tr> | |
| * <tr> | |
| * <th scope="row" > {@link StandardOpenOption#CREATE CREATE} </th> | |
| * <td> If this option is present then an existing file is opened if it | |
| * exists, otherwise a new file is created. When creating a file the check | |
| * for the existence of the file and the creation of the file if it does | |
| * not exist is atomic with respect to other file system operations. This | |
| * option is ignored if the {@code CREATE_NEW} option is also present or | |
| * the file is opened only for reading. </td> | |
| * </tr> | |
| * <tr> | |
| * <th scope="row" > {@link StandardOpenOption#DELETE_ON_CLOSE DELETE_ON_CLOSE} </th> | |
| * <td> When this option is present then the implementation makes a | |
| * <em>best effort</em> attempt to delete the file when closed by | |
| * the {@link #close close} method. If the {@code close} method is not | |
| * invoked then a <em>best effort</em> attempt is made to delete the file | |
| * when the Java virtual machine terminates. </td> | |
| * </tr> | |
| * <tr> | |
| * <th scope="row">{@link StandardOpenOption#SPARSE SPARSE} </th> | |
| * <td> When creating a new file this option is a <em>hint</em> that the | |
| * new file will be sparse. This option is ignored when not creating | |
| * a new file. </td> | |
| * </tr> | |
| * <tr> | |
| * <th scope="row"> {@link StandardOpenOption#SYNC SYNC} </th> | |
| * <td> Requires that every update to the file's content or metadata be | |
| * written synchronously to the underlying storage device. (see <a | |
| * href="../file/package-summary.html#integrity"> Synchronized I/O file | |
| * integrity</a>). </td> | |
| * </tr> | |
| * <tr> | |
| * <th scope="row"> {@link StandardOpenOption#DSYNC DSYNC} </th> | |
| * <td> Requires that every update to the file's content be written | |
| * synchronously to the underlying storage device. (see <a | |
| * href="../file/package-summary.html#integrity"> Synchronized I/O file | |
| * integrity</a>). </td> | |
| * </tr> | |
| * </tbody> | |
| * </table> | |
| * | |
| * <p> An implementation may also support additional options. | |
| * | |
| * <p> The {@code attrs} parameter is an optional array of file {@link | |
| * FileAttribute file-attributes} to set atomically when creating the file. | |
| * | |
| * <p> The new channel is created by invoking the {@link | |
| * FileSystemProvider#newFileChannel newFileChannel} method on the | |
| * provider that created the {@code Path}. | |
| * | |
| * @param path | |
| * The path of the file to open or create | |
| * @param options | |
| * Options specifying how the file is opened | |
| * @param attrs | |
| * An optional list of file attributes to set atomically when | |
| * creating the file | |
| * | |
| * @return A new file channel | |
| * | |
| * @throws IllegalArgumentException | |
| * If the set contains an invalid combination of options | |
| * @throws UnsupportedOperationException | |
| * If the {@code path} is associated with a provider that does not | |
| * support creating file channels, or an unsupported open option is | |
| * specified, or the array contains an attribute that cannot be set | |
| * atomically when creating the file | |
| * @throws FileAlreadyExistsException | |
| * If a file of that name already exists and the {@link | |
| * StandardOpenOption#CREATE_NEW CREATE_NEW} option is specified | |
| * and the file is being opened for writing | |
| * <i>(<a href="../file/package-summary.html#optspecex">optional | |
| * specific exception</a>)</i> | |
| * @throws IOException | |
| * If an I/O error occurs | |
| * | |
| * @since 1.7 | |
| */ | |
| public static FileChannel open(Path path, | |
| Set<? extends OpenOption> options, | |
| FileAttribute<?>... attrs) | |
| throws IOException | |
| { | |
| FileSystemProvider provider = path.getFileSystem().provider(); | |
| return provider.newFileChannel(path, options, attrs); | |
| } | |
| @SuppressWarnings("rawtypes") // generic array construction | |
| private static final FileAttribute<?>[] NO_ATTRIBUTES = new FileAttribute[0]; | |
| /** | |
| * Opens or creates a file, returning a file channel to access the file. | |
| * | |
| * <p> An invocation of this method behaves in exactly the same way as the | |
| * invocation | |
| * {@snippet lang=java : | |
| * // @link substring="open" target="#open(Path,Set,FileAttribute[])" : | |
| * fc.open(file, opts, new FileAttribute<?>[0]); | |
| * } | |
| * where {@code opts} is a set of the options specified in the {@code | |
| * options} array. | |
| * | |
| * @param path | |
| * The path of the file to open or create | |
| * @param options | |
| * Options specifying how the file is opened | |
| * | |
| * @return A new file channel | |
| * | |
| * @throws IllegalArgumentException | |
| * If the set contains an invalid combination of options | |
| * @throws UnsupportedOperationException | |
| * If the {@code path} is associated with a provider that does not | |
| * support creating file channels, or an unsupported open option is | |
| * specified | |
| * @throws FileAlreadyExistsException | |
| * If a file of that name already exists and the {@link | |
| * StandardOpenOption#CREATE_NEW CREATE_NEW} option is specified | |
| * and the file is being opened for writing | |
| * <i>(<a href="../file/package-summary.html#optspecex">optional | |
| * specific exception</a>)</i> | |
| * @throws IOException | |
| * If an I/O error occurs | |
| * | |
| * @since 1.7 | |
| */ | |
| public static FileChannel open(Path path, OpenOption... options) | |
| throws IOException | |
| { | |
| Set<OpenOption> set; | |
| if (options.length == 0) { | |
| set = Collections.emptySet(); | |
| } else { | |
| set = new HashSet<>(); | |
| Collections.addAll(set, options); | |
| } | |
| return open(path, set, NO_ATTRIBUTES); | |
| } | |
| // -- Channel operations -- | |
| /** | |
| * Reads a sequence of bytes from this channel into the given buffer. | |
| * | |
| * <p> Bytes are read starting at this channel's current file position, and | |
| * then the file position is updated with the number of bytes actually | |
| * read. Otherwise this method behaves exactly as specified in the {@link | |
| * ReadableByteChannel} interface. </p> | |
| * | |
| * @throws ClosedChannelException {@inheritDoc} | |
| * @throws AsynchronousCloseException {@inheritDoc} | |
| * @throws ClosedByInterruptException {@inheritDoc} | |
| * @throws NonReadableChannelException {@inheritDoc} | |
| */ | |
| public abstract int read(ByteBuffer dst) throws IOException; | |
| /** | |
| * Reads a sequence of bytes from this channel into a subsequence of the | |
| * given buffers. | |
| * | |
| * <p> Bytes are read starting at this channel's current file position, and | |
| * then the file position is updated with the number of bytes actually | |
| * read. Otherwise this method behaves exactly as specified in the {@link | |
| * ScatteringByteChannel} interface. </p> | |
| * | |
| * @throws ClosedChannelException {@inheritDoc} | |
| * @throws AsynchronousCloseException {@inheritDoc} | |
| * @throws ClosedByInterruptException {@inheritDoc} | |
| * @throws NonReadableChannelException {@inheritDoc} | |
| */ | |
| public abstract long read(ByteBuffer[] dsts, int offset, int length) | |
| throws IOException; | |
| /** | |
| * Reads a sequence of bytes from this channel into the given buffers. | |
| * | |
| * <p> Bytes are read starting at this channel's current file position, and | |
| * then the file position is updated with the number of bytes actually | |
| * read. Otherwise this method behaves exactly as specified in the {@link | |
| * ScatteringByteChannel} interface. </p> | |
| * | |
| * @throws ClosedChannelException {@inheritDoc} | |
| * @throws AsynchronousCloseException {@inheritDoc} | |
| * @throws ClosedByInterruptException {@inheritDoc} | |
| * @throws NonReadableChannelException {@inheritDoc} | |
| */ | |
| public final long read(ByteBuffer[] dsts) throws IOException { | |
| return read(dsts, 0, dsts.length); | |
| } | |
| /** | |
| * Writes a sequence of bytes to this channel from the given buffer. | |
| * | |
| * <p> Bytes are written starting at this channel's current file position | |
| * unless the channel is in append mode, in which case the position is | |
| * first advanced to the end of the file. The file is grown, if necessary, | |
| * to accommodate the written bytes, and then the file position is updated | |
| * with the number of bytes actually written. Otherwise this method | |
| * behaves exactly as specified by the {@link WritableByteChannel} | |
| * interface. </p> | |
| * | |
| * @throws ClosedChannelException {@inheritDoc} | |
| * @throws AsynchronousCloseException {@inheritDoc} | |
| * @throws ClosedByInterruptException {@inheritDoc} | |
| * @throws NonWritableChannelException {@inheritDoc} | |
| */ | |
| public abstract int write(ByteBuffer src) throws IOException; | |
| /** | |
| * Writes a sequence of bytes to this channel from a subsequence of the | |
| * given buffers. | |
| * | |
| * <p> Bytes are written starting at this channel's current file position | |
| * unless the channel is in append mode, in which case the position is | |
| * first advanced to the end of the file. The file is grown, if necessary, | |
| * to accommodate the written bytes, and then the file position is updated | |
| * with the number of bytes actually written. Otherwise this method | |
| * behaves exactly as specified in the {@link GatheringByteChannel} | |
| * interface. </p> | |
| * | |
| * @throws ClosedChannelException {@inheritDoc} | |
| * @throws AsynchronousCloseException {@inheritDoc} | |
| * @throws ClosedByInterruptException {@inheritDoc} | |
| * @throws NonWritableChannelException {@inheritDoc} | |
| */ | |
| public abstract long write(ByteBuffer[] srcs, int offset, int length) | |
| throws IOException; | |
| /** | |
| * Writes a sequence of bytes to this channel from the given buffers. | |
| * | |
| * <p> Bytes are written starting at this channel's current file position | |
| * unless the channel is in append mode, in which case the position is | |
| * first advanced to the end of the file. The file is grown, if necessary, | |
| * to accommodate the written bytes, and then the file position is updated | |
| * with the number of bytes actually written. Otherwise this method | |
| * behaves exactly as specified in the {@link GatheringByteChannel} | |
| * interface. </p> | |
| * | |
| * @throws ClosedChannelException {@inheritDoc} | |
| * @throws AsynchronousCloseException {@inheritDoc} | |
| * @throws ClosedByInterruptException {@inheritDoc} | |
| * @throws NonWritableChannelException {@inheritDoc} | |
| */ | |
| public final long write(ByteBuffer[] srcs) throws IOException { | |
| return write(srcs, 0, srcs.length); | |
| } | |
| // -- Other operations -- | |
| /** | |
| * Returns this channel's file position. | |
| * | |
| * @return This channel's file position, | |
| * a non-negative integer counting the number of bytes | |
| * from the beginning of the file to the current position | |
| * | |
| * @throws ClosedChannelException | |
| * If this channel is closed | |
| * | |
| * @throws IOException | |
| * If some other I/O error occurs | |
| */ | |
| public abstract long position() throws IOException; | |
| /** | |
| * Sets this channel's file position. | |
| * | |
| * <p> Setting the position to a value that is greater than the file's | |
| * current size is legal but does not change the size of the file. A later | |
| * attempt to read bytes at such a position will immediately return an | |
| * end-of-file indication. A later attempt to write bytes at such a | |
| * position will cause the file to 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. </p> | |
| * | |
| * @param newPosition | |
| * The new position, a non-negative integer counting | |
| * the number of bytes from the beginning of the file | |
| * | |
| * @return This file channel | |
| * | |
| * @throws ClosedChannelException | |
| * If this channel is closed | |
| * | |
| * @throws IllegalArgumentException | |
| * If the new position is negative | |
| * | |
| * @throws IOException | |
| * If some other I/O error occurs | |
| */ | |
| public abstract FileChannel position(long newPosition) throws IOException; | |
| /** | |
| * Returns the current size of this channel's file. | |
| * | |
| * @return The current size of this channel's file, | |
| * measured in bytes | |
| * | |
| * @throws ClosedChannelException | |
| * If this channel is closed | |
| * | |
| * @throws IOException | |
| * If some other I/O error occurs | |
| */ | |
| public abstract long size() throws IOException; | |
| /** | |
| * Truncates this channel's file to the given size. | |
| * | |
| * <p> If the given size is less than the file's current size then the file | |
| * is truncated, discarding any bytes beyond the new end of the file. If | |
| * the given size is greater than or equal to the file's current size then | |
| * the file is not modified. In either case, if this channel's file | |
| * position is greater than the given size then it is set to that size. | |
| * </p> | |
| * | |
| * @param size | |
| * The new size, a non-negative byte count | |
| * | |
| * @return This file channel | |
| * | |
| * @throws NonWritableChannelException | |
| * If this channel was not opened for writing | |
| * | |
| * @throws ClosedChannelException | |
| * If this channel is closed | |
| * | |
| * @throws IllegalArgumentException | |
| * If the new size is negative | |
| * | |
| * @throws IOException | |
| * If some other I/O error occurs | |
| */ | |
| public abstract FileChannel truncate(long size) throws IOException; | |
| /** | |
| * Forces any updates to this channel's file to be written to the storage | |
| * device that contains it. | |
| * | |
| * <p> If this channel's file resides on a local storage device then when | |
| * this method returns it is guaranteed that all changes made to the file | |
| * since this channel was created, or since this method was last invoked, | |
| * will have been written to that device. This is useful for ensuring that | |
| * critical information is not lost in the event of a system crash. | |
| * | |
| * <p> If the file does not reside on a local device then no such guarantee | |
| * is made. | |
| * | |
| * <p> The {@code metaData} parameter can be used to limit the number of | |
| * I/O operations that this method is required to perform. Passing | |
| * {@code false} for this parameter indicates that only updates to the | |
| * file's content need be written to storage; passing {@code true} | |
| * indicates that updates to both the file's content and metadata must be | |
| * written, which generally requires at least one more I/O operation. | |
| * Whether this parameter actually has any effect is dependent upon the | |
| * underlying operating system and is therefore unspecified. | |
| * | |
| * <p> Invoking this method may cause an I/O operation to occur even if the | |
| * channel was only opened for reading. Some operating systems, for | |
| * example, maintain a last-access time as part of a file's metadata, and | |
| * this time is updated whenever the file is read. Whether or not this is | |
| * actually done is system-dependent and is therefore unspecified. | |
| * | |
| * <p> This method is only guaranteed to force changes that were made to | |
| * this channel's file via the methods defined in this class, or the methods | |
| * defined by {@link java.io.FileOutputStream} or | |
| * {@link java.io.RandomAccessFile} when the channel was obtained with the | |
| * {@code getChannel} method. It may or may not force changes that were made | |
| * by modifying the content of a | |
| * {@link MappedByteBuffer <i>mapped byte buffer</i>} obtained by | |
| * invoking the {@link #map map} method. Invoking the {@link | |
| * MappedByteBuffer#force force} method of the mapped byte buffer will | |
| * force changes made to the buffer's content to be written. </p> | |
| * | |
| * @param metaData | |
| * If {@code true} then this method is required to force changes | |
| * to both the file's content and metadata to be written to | |
| * storage; otherwise, it need only force content changes to be | |
| * written | |
| * | |
| * @throws ClosedChannelException | |
| * If this channel is closed | |
| * | |
| * @throws IOException | |
| * If some other I/O error occurs | |
| */ | |
| public abstract void force(boolean metaData) throws IOException; | |
| /** | |
| * Transfers bytes from this channel's file to the given writable byte | |
| * channel. | |
| * | |
| * <p> An attempt is made to read up to {@code count} bytes starting at | |
| * the given {@code position} in this channel's file and write them to the | |
| * target channel. An invocation of this method may or may not transfer | |
| * all of the requested bytes; whether or not it does so depends upon the | |
| * natures and states of the channels. Fewer than the requested number of | |
| * bytes are transferred if this channel's file contains fewer than | |
| * {@code count} bytes starting at the given {@code position}, or if the | |
| * target channel is non-blocking and it has fewer than {@code count} | |
| * bytes free in its output buffer. | |
| * | |
| * <p> This method does not modify this channel's position. If the given | |
| * position is greater than or equal to the file's current size then no | |
| * bytes are transferred. If the target channel has a position then bytes | |
| * are written starting at that position and then the position | |
| * is incremented by the number of bytes written. | |
| * | |
| * <p> This method is potentially much more efficient than a simple loop | |
| * that reads from this channel and writes to the target channel. Many | |
| * operating systems can transfer bytes directly from the filesystem cache | |
| * to the target channel without actually copying them. </p> | |
| * | |
| * @param position | |
| * The position within the file at which the transfer is to begin; | |
| * must be non-negative | |
| * | |
| * @param count | |
| * The maximum number of bytes to be transferred; must be | |
| * non-negative | |
| * | |
| * @param target | |
| * The target channel | |
| * | |
| * @return The number of bytes, possibly zero, | |
| * that were actually transferred | |
| * | |
| * @throws IllegalArgumentException | |
| * If the preconditions on the parameters do not hold | |
| * | |
| * @throws NonReadableChannelException | |
| * If this channel was not opened for reading | |
| * | |
| * @throws NonWritableChannelException | |
| * If the target channel was not opened for writing | |
| * | |
| * @throws ClosedChannelException | |
| * If either this channel or the target channel is closed | |
| * | |
| * @throws AsynchronousCloseException | |
| * If another thread closes either channel | |
| * while the transfer is in progress | |
| * | |
| * @throws ClosedByInterruptException | |
| * If another thread interrupts the current thread while the | |
| * transfer is in progress, thereby closing both channels and | |
| * setting the current thread's interrupt status | |
| * | |
| * @throws IOException | |
| * If some other I/O error occurs | |
| */ | |
| public abstract long transferTo(long position, long count, | |
| WritableByteChannel target) | |
| throws IOException; | |
| /** | |
| * Transfers bytes into this channel's file from the given readable byte | |
| * channel. | |
| * | |
| * <p> An attempt is made to read up to {@code count} bytes from the | |
| * source channel and write them to this channel's file starting at the | |
| * given {@code position}. An invocation of this method may or may not | |
| * transfer all of the requested bytes; whether or not it does so depends | |
| * upon the natures and states of the channels. Fewer than the requested | |
| * number of bytes will be transferred if the source channel has fewer than | |
| * {@code count} bytes remaining, or if the source channel is non-blocking | |
| * and has fewer than {@code count} bytes immediately available in its | |
| * input buffer. No bytes are transferred, and zero is returned, if the | |
| * source has reached end-of-stream. | |
| * | |
| * <p> This method does not modify this channel's position. If the given | |
| * position is greater than or equal to the file's current size 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. If the source channel has a position then bytes are read | |
| * starting at that position and then the position is incremented by the | |
| * number of bytes read. | |
| * | |
| * <p> This method is potentially much more efficient than a simple loop | |
| * that reads from the source channel and writes to this channel. Many | |
| * operating systems can transfer bytes directly from the source channel | |
| * into the filesystem cache without actually copying them. </p> | |
| * | |
| * @param src | |
| * The source channel | |
| * | |
| * @param position | |
| * The file position at which the transfer is to begin; | |
| * must be non-negative | |
| * | |
| * @param count | |
| * The maximum number of bytes to be transferred; must be | |
| * non-negative | |
| * | |
| * @return The number of bytes, possibly zero, | |
| * that were actually transferred | |
| * | |
| * @throws IllegalArgumentException | |
| * If the preconditions on the parameters do not hold | |
| * | |
| * @throws NonReadableChannelException | |
| * If the source channel was not opened for reading | |
| * | |
| * @throws NonWritableChannelException | |
| * If this channel was not opened for writing | |
| * | |
| * @throws ClosedChannelException | |
| * If either this channel or the source channel is closed | |
| * | |
| * @throws AsynchronousCloseException | |
| * If another thread closes either channel | |
| * while the transfer is in progress | |
| * | |
| * @throws ClosedByInterruptException | |
| * If another thread interrupts the current thread while the | |
| * transfer is in progress, thereby closing both channels and | |
| * setting the current thread's interrupt status | |
| * | |
| * @throws IOException | |
| * If some other I/O error occurs | |
| */ | |
| public abstract long transferFrom(ReadableByteChannel src, | |
| long position, long count) | |
| throws IOException; | |
| /** | |
| * Reads a sequence of bytes from this channel into the given buffer, | |
| * starting at the given file position. | |
| * | |
| * <p> This method works in the same manner as the {@link | |
| * #read(ByteBuffer)} method, except that bytes are read starting at the | |
| * given file position rather than at the channel's current position. This | |
| * method does not modify this channel's position. If the given position | |
| * is greater than or equal to the file's current size then no bytes are | |
| * read. </p> | |
| * | |
| * @param dst | |
| * The buffer into which bytes are to be transferred | |
| * | |
| * @param position | |
| * The file position at which the transfer is to begin; | |
| * must be non-negative | |
| * | |
| * @return The number of bytes read, possibly zero, or {@code -1} if the | |
| * given position is greater than or equal to the file's current | |
| * size | |
| * | |
| * @throws IllegalArgumentException | |
| * If the position is negative or the buffer is read-only | |
| * | |
| * @throws NonReadableChannelException | |
| * If this channel was not opened for reading | |
| * | |
| * @throws ClosedChannelException | |
| * If this channel is closed | |
| * | |
| * @throws AsynchronousCloseException | |
| * If another thread closes this channel | |
| * while the read operation is in progress | |
| * | |
| * @throws ClosedByInterruptException | |
| * If another thread interrupts the current thread | |
| * while the read operation is in progress, thereby | |
| * closing the channel and setting the current thread's | |
| * interrupt status | |
| * | |
| * @throws IOException | |
| * If some other I/O error occurs | |
| */ | |
| public abstract int read(ByteBuffer dst, long position) throws IOException; | |
| /** | |
| * Writes a sequence of bytes to this channel from the given buffer, | |
| * starting at the given file position. | |
| * | |
| * <p> This method works in the same manner as the {@link | |
| * #write(ByteBuffer)} method, except that bytes are written starting at | |
| * the given file position rather than at the channel's current position. | |
| * This method does not modify this channel's position. If the given | |
| * position is greater than or equal to the file's current size 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. </p> | |
| * | |
| * <p> If the file is open in <a href="#append-mode">append mode</a>, then | |
| * the effect of invoking this method is unspecified. | |
| * | |
| * @param src | |
| * The buffer from which bytes are to be transferred | |
| * | |
| * @param position | |
| * The file position at which the transfer is to begin; | |
| * must be non-negative | |
| * | |
| * @return The number of bytes written, possibly zero | |
| * | |
| * @throws IllegalArgumentException | |
| * If the position is negative | |
| * | |
| * @throws NonWritableChannelException | |
| * If this channel was not opened for writing | |
| * | |
| * @throws ClosedChannelException | |
| * If this channel is closed | |
| * | |
| * @throws AsynchronousCloseException | |
| * If another thread closes this channel | |
| * while the write operation is in progress | |
| * | |
| * @throws ClosedByInterruptException | |
| * If another thread interrupts the current thread | |
| * while the write operation is in progress, thereby | |
| * closing the channel and setting the current thread's | |
| * interrupt status | |
| * | |
| * @throws IOException | |
| * If some other I/O error occurs | |
| */ | |
| public abstract int write(ByteBuffer src, long position) throws IOException; | |
| // -- Memory-mapped buffers -- | |
| /** | |
| * A file-mapping mode. | |
| * | |
| * @since 1.4 | |
| * | |
| * @see java.nio.channels.FileChannel#map | |
| */ | |
| public static class MapMode { | |
| /** | |
| * Mode for a read-only mapping. | |
| */ | |
| public static final MapMode READ_ONLY | |
| = new MapMode("READ_ONLY"); | |
| /** | |
| * Mode for a read/write mapping. | |
| */ | |
| public static final MapMode READ_WRITE | |
| = new MapMode("READ_WRITE"); | |
| /** | |
| * Mode for a private (copy-on-write) mapping. | |
| */ | |
| public static final MapMode PRIVATE | |
| = new MapMode("PRIVATE"); | |
| private final String name; | |
| /** | |
| * Constructs an instance of this class. This constructor may be used | |
| * by code in java.base to create file mapping modes beyond the file | |
| * mapping modes defined here. | |
| * @param name the name of the map mode | |
| */ | |
| private MapMode(String name) { | |
| this.name = name; | |
| } | |
| /** | |
| * Returns a string describing this file-mapping mode. | |
| * | |
| * @return A descriptive string | |
| */ | |
| public String toString() { | |
| return name; | |
| } | |
| } | |
| /** | |
| * Maps a region of this channel's file directly into memory. | |
| * | |
| * <p> The {@code mode} parameter specifies how the region of the file is | |
| * mapped and may be one of the following modes: | |
| * | |
| * <ul> | |
| * | |
| * <li><p> <i>Read-only:</i> Any attempt to modify the resulting buffer | |
| * will cause a {@link java.nio.ReadOnlyBufferException} to be thrown. | |
| * ({@link MapMode#READ_ONLY MapMode.READ_ONLY}) </p></li> | |
| * | |
| * <li><p> <i>Read/write:</i> Changes made to the resulting buffer will | |
| * eventually be propagated to the file; they may or may not be made | |
| * visible to other programs that have mapped the same file. ({@link | |
| * MapMode#READ_WRITE MapMode.READ_WRITE}) </p></li> | |
| * | |
| * <li><p> <i>Private:</i> Changes made to the resulting buffer will not | |
| * be propagated to the file and will not be visible to other programs | |
| * that have mapped the same file; instead, they will cause private | |
| * copies of the modified portions of the buffer to be created. ({@link | |
| * MapMode#PRIVATE MapMode.PRIVATE}) </p></li> | |
| * | |
| * </ul> | |
| * | |
| * <p> An implementation may support additional map modes. | |
| * | |
| * <p> For a read-only mapping, this channel must have been opened for | |
| * reading; for a read/write or private mapping, this channel must have | |
| * been opened for both reading and writing. | |
| * | |
| * <p> The {@link MappedByteBuffer <i>mapped byte buffer</i>} | |
| * returned by this method will have a position of zero and a limit and | |
| * capacity of {@code size}; its mark will be undefined. The buffer and | |
| * the mapping that it represents will remain valid until the buffer itself | |
| * is garbage-collected. | |
| * | |
| * <p> A mapping, once established, is not dependent upon the file channel | |
| * that was used to create it. Closing the channel, in particular, has no | |
| * effect upon the validity of the mapping. | |
| * | |
| * <p> Many of the details of memory-mapped files are inherently dependent | |
| * upon the underlying operating system and are therefore unspecified. The | |
| * behavior of this method when the requested region is not completely | |
| * contained within this channel's file is unspecified. Whether changes | |
| * made to the content or size of the underlying file, by this program or | |
| * another, are propagated to the buffer is unspecified. The rate at which | |
| * changes to the buffer are propagated to the file is unspecified. | |
| * | |
| * <p> For most operating systems, mapping a file into memory is more | |
| * expensive than reading or writing a few tens of kilobytes of data via | |
| * the usual {@link #read read} and {@link #write write} methods. From the | |
| * standpoint of performance it is generally only worth mapping relatively | |
| * large files into memory. </p> | |
| * | |
| * @param mode | |
| * One of the constants {@link MapMode#READ_ONLY READ_ONLY}, {@link | |
| * MapMode#READ_WRITE READ_WRITE}, or {@link MapMode#PRIVATE | |
| * PRIVATE} defined in the {@link MapMode} class, according to | |
| * whether the file is to be mapped read-only, read/write, or | |
| * privately (copy-on-write), respectively, or an implementation | |
| * specific map mode | |
| * | |
| * @param position | |
| * The position within the file at which the mapped region | |
| * is to start; must be non-negative | |
| * | |
| * @param size | |
| * The size of the region to be mapped; must be non-negative and | |
| * no greater than {@link java.lang.Integer#MAX_VALUE} | |
| * | |
| * @return The mapped byte buffer | |
| * | |
| * @throws NonReadableChannelException | |
| * If the {@code mode} is {@link MapMode#READ_ONLY READ_ONLY} or | |
| * an implementation specific map mode requiring read access, | |
| * but this channel was not opened for reading | |
| * | |
| * @throws NonWritableChannelException | |
| * If the {@code mode} is {@link MapMode#READ_WRITE READ_WRITE}, | |
| * {@link MapMode#PRIVATE PRIVATE} or an implementation specific | |
| * map mode requiring write access, but this channel was not | |
| * opened for both reading and writing | |
| * | |
| * @throws IllegalArgumentException | |
| * If the preconditions on the parameters do not hold | |
| * | |
| * @throws UnsupportedOperationException | |
| * If an unsupported map mode is specified | |
| * | |
| * @throws IOException | |
| * If some other I/O error occurs | |
| * | |
| * @see java.nio.channels.FileChannel.MapMode | |
| * @see java.nio.MappedByteBuffer | |
| */ | |
| public abstract MappedByteBuffer map(MapMode mode, long position, long size) | |
| throws IOException; | |
| /** | |
| * Maps a region of this channel's file into a new mapped memory segment, | |
| * with the given offset, size and arena. | |
| * The {@linkplain MemorySegment#address() address} of the returned memory | |
| * segment is the starting address of the mapped off-heap region backing | |
| * the segment. | |
| * <p> | |
| * The lifetime of the returned segment is controlled by the provided arena. | |
| * For instance, if the provided arena is a closeable arena, | |
| * the returned segment will be unmapped when the provided closeable arena | |
| * is {@linkplain Arena#close() closed}. | |
| * <p> If the specified mapping mode is | |
| * {@linkplain FileChannel.MapMode#READ_ONLY READ_ONLY}, the resulting | |
| * segment will be read-only (see {@link MemorySegment#isReadOnly()}). | |
| * | |
| * <p> The content of a mapped memory segment can change at any time, for | |
| * example if the content of the corresponding region of the mapped file is | |
| * changed by this (or another) program. Whether such changes occur, and | |
| * when they occur, is operating-system dependent and therefore unspecified. | |
| * | |
| * <p> All or part of a mapped memory segment may become inaccessible at any | |
| * time, for example if the backing mapped file is truncated. An attempt to | |
| * access an inaccessible region of a mapped memory segment will not change | |
| * the segment's content and will cause an unspecified exception to be | |
| * thrown either at the time of the access or at some later time. It is | |
| * therefore strongly recommended that appropriate precautions be taken to | |
| * avoid the manipulation of a mapped file by this (or another) program, | |
| * except to read or write the file's content. | |
| * | |
| * @implNote When obtaining a mapped segment from a newly created file | |
| * channel, the initialization state of the contents of the block | |
| * of mapped memory associated with the returned mapped memory | |
| * segment is unspecified and should not be relied upon. | |
| * | |
| * @implSpec The default implementation of this method throws | |
| * {@code UnsupportedOperationException}. | |
| * | |
| * @param mode | |
| * The file mapping mode, see | |
| * {@link FileChannel#map(FileChannel.MapMode, long, long)}; | |
| * the mapping mode might affect the behavior of the returned | |
| * memory mapped segment (see {@link MemorySegment#force()}) | |
| * | |
| * @param offset | |
| * The offset (expressed in bytes) within the file at which the | |
| * mapped segment is to start | |
| * | |
| * @param size | |
| * The size (in bytes) of the mapped memory backing the memory | |
| * segment | |
| * | |
| * @param arena | |
| * The segment arena | |
| * | |
| * @return A new mapped memory segment | |
| * | |
| * @throws IllegalArgumentException | |
| * If {@code offset < 0}, {@code size < 0} or | |
| * {@code offset + size} overflows the range of {@code long} | |
| * | |
| * @throws IllegalStateException | |
| * If {@code arena.isAlive() == false} | |
| * | |
| * @throws WrongThreadException | |
| * If {@code arena} is a confined scoped arena, and this method is called | |
| * from a thread {@code T}, other than the scoped arena's owner thread | |
| * | |
| * @throws NonReadableChannelException | |
| * If the {@code mode} is {@link MapMode#READ_ONLY READ_ONLY} or | |
| * an implementation specific map mode requiring read access, | |
| * but this channel was not opened for reading | |
| * | |
| * @throws NonWritableChannelException | |
| * If the {@code mode} is {@link MapMode#READ_WRITE READ_WRITE}, | |
| * {@link MapMode#PRIVATE PRIVATE} or an implementation specific | |
| * map mode requiring write access, but this channel was not | |
| * opened for both reading and writing | |
| * | |
| * @throws IOException | |
| * If some other I/O error occurs | |
| * | |
| * @throws UnsupportedOperationException | |
| * If an unsupported map mode is specified | |
| * | |
| * @since 22 | |
| */ | |
| public MemorySegment map(MapMode mode, long offset, long size, Arena arena) | |
| throws IOException | |
| { | |
| throw new UnsupportedOperationException(); | |
| } | |
| // -- Locks -- | |
| /** | |
| * Acquires a lock on the given region of this channel's file. | |
| * | |
| * <p> An invocation of this method will block until the region can be | |
| * locked, this channel is closed, or the invoking thread is interrupted, | |
| * whichever comes first. | |
| * | |
| * <p> If this channel is closed by another thread during an invocation of | |
| * this method then an {@link AsynchronousCloseException} will be thrown. | |
| * | |
| * <p> If the invoking thread is interrupted while waiting to acquire the | |
| * lock then its interrupt status will be set and a {@link | |
| * FileLockInterruptionException} will be thrown. If the invoker's | |
| * interrupt status is set when this method is invoked then that exception | |
| * will be thrown immediately; the thread's interrupt status will not be | |
| * changed. | |
| * | |
| * <p> The region specified by the {@code position} and {@code 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 zero-argument | |
| * {@link #lock()} method simply locks a region of size {@link | |
| * Long#MAX_VALUE}. If the {@code position} is non-negative and the | |
| * {@code size} is zero, then a lock of size | |
| * {@code Long.MAX_VALUE - position} is returned. | |
| * | |
| * <p> 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 {@link | |
| * FileLock#isShared() isShared} method. | |
| * | |
| * <p> 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. </p> | |
| * | |
| * @param position | |
| * The position at which the locked region is to start; must be | |
| * non-negative | |
| * | |
| * @param size | |
| * The size of the locked region; must be non-negative, and the sum | |
| * {@code position} + {@code 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 | |
| * | |
| * @param shared | |
| * {@code true} to request a shared lock, in which case this | |
| * channel must be open for reading (and possibly writing); | |
| * {@code false} to request an exclusive lock, in which case this | |
| * channel must be open for writing (and possibly reading) | |
| * | |
| * @return A lock object representing the newly-acquired lock | |
| * | |
| * @throws IllegalArgumentException | |
| * If the preconditions on the parameters do not hold | |
| * | |
| * @throws ClosedChannelException | |
| * If this channel is closed | |
| * | |
| * @throws AsynchronousCloseException | |
| * If another thread closes this channel while the invoking | |
| * thread is blocked in this method | |
| * | |
| * @throws FileLockInterruptionException | |
| * If the invoking thread is interrupted while blocked in this | |
| * method | |
| * | |
| * @throws OverlappingFileLockException | |
| * If a lock that overlaps the requested region is already held by | |
| * this Java virtual machine, or if another thread is already | |
| * blocked in this method and is attempting to lock an overlapping | |
| * region | |
| * | |
| * @throws NonReadableChannelException | |
| * If {@code shared} is {@code true} but this channel was not | |
| * opened for reading | |
| * | |
| * @throws NonWritableChannelException | |
| * If {@code shared} is {@code false} but this channel was not | |
| * opened for writing | |
| * | |
| * @throws IOException | |
| * If some other I/O error occurs | |
| * | |
| * @see #lock() | |
| * @see #tryLock() | |
| * @see #tryLock(long,long,boolean) | |
| */ | |
| public abstract FileLock lock(long position, long size, boolean shared) | |
| throws IOException; | |
| /** | |
| * Acquires an exclusive lock on this channel's file. | |
| * | |
| * <p> An invocation of this method of the form {@code fc.lock()} behaves | |
| * in exactly the same way as the invocation | |
| * | |
| * {@snippet lang=java : | |
| * // @link substring="lock" target="#lock(long,long,boolean)" : | |
| * fc.lock(0L, Long.MAX_VALUE, false) | |
| * } | |
| * | |
| * @return A lock object representing the newly-acquired lock | |
| * | |
| * @throws ClosedChannelException | |
| * If this channel is closed | |
| * | |
| * @throws AsynchronousCloseException | |
| * If another thread closes this channel while the invoking | |
| * thread is blocked in this method | |
| * | |
| * @throws FileLockInterruptionException | |
| * If the invoking thread is interrupted while blocked in this | |
| * method | |
| * | |
| * @throws OverlappingFileLockException | |
| * If a lock that overlaps the requested region is already held by | |
| * this Java virtual machine, or if another thread is already | |
| * blocked in this method and is attempting to lock an overlapping | |
| * region of the same file | |
| * | |
| * @throws NonWritableChannelException | |
| * If this channel was not opened for writing | |
| * | |
| * @throws IOException | |
| * If some other I/O error occurs | |
| * | |
| * @see #lock(long,long,boolean) | |
| * @see #tryLock() | |
| * @see #tryLock(long,long,boolean) | |
| */ | |
| public final FileLock lock() throws IOException { | |
| return lock(0L, Long.MAX_VALUE, false); | |
| } | |
| /** | |
| * Attempts to acquire a lock on the given region of this channel's file. | |
| * | |
| * <p> This method does not block. An invocation always returns | |
| * immediately, either having acquired a lock on the requested region or | |
| * having failed to do so. If it fails to acquire a lock because an | |
| * overlapping lock is held by another program then it returns | |
| * {@code null}. If it fails to acquire a lock for any other reason then | |
| * an appropriate exception is thrown. | |
| * | |
| * <p> The region specified by the {@code position} and {@code 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 zero-argument | |
| * {@link #tryLock()} method simply locks a region of size {@link | |
| * Long#MAX_VALUE}. If the {@code position} is non-negative and the | |
| * {@code size} is zero, then a lock of size | |
| * {@code Long.MAX_VALUE - position} is returned. | |
| * | |
| * <p> 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 {@link | |
| * FileLock#isShared() isShared} method. | |
| * | |
| * <p> 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. </p> | |
| * | |
| * @param position | |
| * The position at which the locked region is to start; must be | |
| * non-negative | |
| * | |
| * @param size | |
| * The size of the locked region; must be non-negative, and the sum | |
| * {@code position} + {@code 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 | |
| * | |
| * @param shared | |
| * {@code true} to request a shared lock, | |
| * {@code false} to request an exclusive lock | |
| * | |
| * @return A lock object representing the newly-acquired lock, | |
| * or {@code null} if the lock could not be acquired | |
| * because another program holds an overlapping lock | |
| * | |
| * @throws IllegalArgumentException | |
| * If the preconditions on the parameters do not hold | |
| * | |
| * @throws ClosedChannelException | |
| * If this channel is closed | |
| * | |
| * @throws OverlappingFileLockException | |
| * If a lock that overlaps the requested region is already held by | |
| * this Java virtual machine, or if another thread is already | |
| * blocked in this method and is attempting to lock an overlapping | |
| * region of the same file | |
| * | |
| * @throws NonReadableChannelException | |
| * If {@code shared} is {@code true} but this channel was not | |
| * opened for reading | |
| * | |
| * @throws NonWritableChannelException | |
| * If {@code shared} is {@code false} but this channel was not | |
| * opened for writing | |
| * | |
| * @throws IOException | |
| * If some other I/O error occurs | |
| * | |
| * @see #lock() | |
| * @see #lock(long,long,boolean) | |
| * @see #tryLock() | |
| */ | |
| public abstract FileLock tryLock(long position, long size, boolean shared) | |
| throws IOException; | |
| /** | |
| * Attempts to acquire an exclusive lock on this channel's file. | |
| * | |
| * <p> An invocation of this method of the form {@code fc.tryLock()} | |
| * behaves in exactly the same way as the invocation | |
| * | |
| * {@snippet lang=java : | |
| * // @link substring="tryLock" target="#tryLock(long,long,boolean)" : | |
| * fc.tryLock(0L, Long.MAX_VALUE, false) | |
| * } | |
| * | |
| * @return A lock object representing the newly-acquired lock, | |
| * or {@code null} if the lock could not be acquired | |
| * because another program holds an overlapping lock | |
| * | |
| * @throws ClosedChannelException | |
| * If this channel is closed | |
| * | |
| * @throws OverlappingFileLockException | |
| * If a lock that overlaps the requested region is already held by | |
| * this Java virtual machine, or if another thread is already | |
| * blocked in this method and is attempting to lock an overlapping | |
| * region | |
| * | |
| * @throws NonWritableChannelException | |
| * If this channel was not opened for writing | |
| * | |
| * @throws IOException | |
| * If some other I/O error occurs | |
| * | |
| * @see #lock() | |
| * @see #lock(long,long,boolean) | |
| * @see #tryLock(long,long,boolean) | |
| */ | |
| public final FileLock tryLock() throws IOException { | |
| return tryLock(0L, Long.MAX_VALUE, false); | |
| } | |
| } |