Java tutorial
/* * Copyright (c) 2000, 2018, 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.*; import java.nio.ByteBuffer; import java.nio.MappedByteBuffer; import java.nio.channels.spi.AbstractInterruptibleChannel; import java.nio.file.*; import java.nio.file.attribute.FileAttribute; import java.nio.file.spi.*; import java.util.Set; import java.util.HashSet; import java.util.Collections; /** * 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. * * <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. * * @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. 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 IOException * If an I/O error occurs * @throws SecurityException * If a security manager is installed and it denies an * unspecified permission required by the implementation. * In the case of the default provider, the {@link * SecurityManager#checkRead(String)} method is invoked to check * read access if the file is opened for reading. The {@link * SecurityManager#checkWrite(String)} method is invoked to check * write access if the file is opened for writing * * @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({ "unchecked", "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 * <pre> * fc.{@link #open(Path,Set,FileAttribute[]) open}(file, opts, new FileAttribute<?>[0]); * </pre> * 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 IOException * If an I/O error occurs * @throws SecurityException * If a security manager is installed and it denies an * unspecified permission required by the implementation. * In the case of the default provider, the {@link * SecurityManager#checkRead(String)} method is invoked to check * read access if the file is opened for reading. The {@link * SecurityManager#checkWrite(String)} method is invoked to check * write access if the file is opened for writing * * @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> */ 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> */ 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> */ 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> */ 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> */ 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> */ 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. 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 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. * * <p> This method does not modify this channel's position. If the given * position is greater than the file's current size then no bytes are * transferred. 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 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 * * @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 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 * * @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 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> * * @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; // -- 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}. * * <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 * * @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} 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 * * <pre> * fc.{@link #lock(long,long,boolean) lock}(0L, Long.MAX_VALUE, false) </pre> * * @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}. * * <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 * * @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 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 * * <pre> * fc.{@link #tryLock(long,long,boolean) tryLock}(0L, Long.MAX_VALUE, false) </pre> * * @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 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); } }