src.java.nio.channels.FileChannel Maven / Gradle / Ivy
Show all versions of android-all Show documentation
/*
* Copyright (c) 2000, 2013, 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.
*
* A file channel is a {@link SeekableByteChannel} that is connected to
* a file. It has a current position within its file which can
* be both {@link #position() queried} and {@link #position(long)
* modified}. The file itself contains a variable-length sequence
* of bytes that can be read and written and whose current {@link #size
* size} 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 truncated}. The
* file may also have some associated metadata such as access
* permissions, content type, and last-modification time; this class does not
* define methods for metadata access.
*
*
In addition to the familiar read, write, and close operations of byte
* channels, this class defines the following file-specific operations:
*
*
*
* Bytes may be {@link #read(ByteBuffer, long) read} or
* {@link #write(ByteBuffer, long) written} at an absolute
* position in a file in a way that does not affect the channel's current
* position.
A region of a file may be {@link #map mapped}
* directly into memory; for large files this is often much more efficient
* than invoking the usual read or write methods.
*
Updates made to a file may be {@link #force forced
* out} to the underlying storage device, ensuring that data are not
* lost in the event of a system crash.
Bytes can be transferred from a file {@link #transferTo to
* some other channel}, and {@link #transferFrom vice
* versa}, in a way that can be optimized by many operating systems
* into a very fast transfer directly to or from the filesystem cache.
*
A region of a file may be {@link FileLock locked}
* against access by other programs.
*
* 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.
*
*
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.
*
*
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 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 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.
*
*
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 "r" and will be open for reading and writing
* if the instance was created with mode "rw".
*
*
A file channel that is open for writing may be in
* append mode, 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 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.
*
*
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.
*
*
In the addition to {@code READ} and {@code WRITE}, the following
* options may be present:
*
*
* Option Description
*
* {@link StandardOpenOption#APPEND APPEND}
* 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.
*
*
* {@link StandardOpenOption#TRUNCATE_EXISTING TRUNCATE_EXISTING}
* 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.
*
*
* {@link StandardOpenOption#CREATE_NEW CREATE_NEW}
* 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.
*
*
* {@link StandardOpenOption#CREATE CREATE}
* 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.
*
*
* {@link StandardOpenOption#DELETE_ON_CLOSE DELETE_ON_CLOSE}
* When this option is present then the implementation makes a
* best effort attempt to delete the file when closed by the
* the {@link #close close} method. If the {@code close} method is not
* invoked then a best effort attempt is made to delete the file
* when the Java virtual machine terminates.
*
*
* {@link StandardOpenOption#SPARSE SPARSE}
* When creating a new file this option is a hint that the
* new file will be sparse. This option is ignored when not creating
* a new file.
*
*
* {@link StandardOpenOption#SYNC SYNC}
* Requires that every update to the file's content or metadata be
* written synchronously to the underlying storage device. (see Synchronized I/O file
* integrity).
*
*
* {@link StandardOpenOption#DSYNC DSYNC}
* Requires that every update to the file's content be written
* synchronously to the underlying storage device. (see Synchronized I/O file
* integrity).
*
*
*
* An implementation may also support additional options.
*
*
The {@code attrs} parameter is an optional array of file {@link
* FileAttribute file-attributes} to set atomically when creating the file.
*
*
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 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.
*
*
An invocation of this method behaves in exactly the same way as the
* invocation
*
* fc.{@link #open(Path,Set,FileAttribute[]) 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 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 set = new HashSet(options.length);
Collections.addAll(set, options);
return open(path, set, NO_ATTRIBUTES);
}
// -- Channel operations --
/**
* Reads a sequence of bytes from this channel into the given buffer.
*
* 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.
*/
public abstract int read(ByteBuffer dst) throws IOException;
/**
* Reads a sequence of bytes from this channel into a subsequence of the
* given buffers.
*
* 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.
*/
public abstract long read(ByteBuffer[] dsts, int offset, int length)
throws IOException;
/**
* Reads a sequence of bytes from this channel into the given buffers.
*
* 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.
*/
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.
*
* 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.
*/
public abstract int write(ByteBuffer src) throws IOException;
/**
* Writes a sequence of bytes to this channel from a subsequence of the
* given buffers.
*
* 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.
*/
public abstract long write(ByteBuffer[] srcs, int offset, int length)
throws IOException;
/**
* Writes a sequence of bytes to this channel from the given buffers.
*
* 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.
*/
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.
*
* 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.
*
* @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.
*
* 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.
*
*
* @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.
*
* 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.
*
*
If the file does not reside on a local device then no such guarantee
* is made.
*
*
The metaData parameter can be used to limit the number of
* I/O operations that this method is required to perform. Passing
* false for this parameter indicates that only updates to the
* file's content need be written to storage; passing 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.
*
*
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.
*
*
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 mapped byte buffer} 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.
*
* @param metaData
* If 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.
*
* An attempt is made to read up to count bytes starting at
* the given 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
* count bytes starting at the given position, or if the
* target channel is non-blocking and it has fewer than count
* bytes free in its output buffer.
*
*
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.
*
*
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.
*
* @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.
*
* An attempt is made to read up to count bytes from the
* source channel and write them to this channel's file starting at the
* given 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
* count bytes remaining, or if the source channel is non-blocking
* and has fewer than count bytes immediately available in its
* input buffer.
*
*
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.
*
*
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.
*
* @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.
*
* 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.
*
* @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 -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.
*
* 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.
*
* @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 typesafe enumeration for file-mapping modes.
*
* @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;
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.
*
* A region of a file may be mapped into memory in one of three modes:
*
*
*
*
* Read-only: Any attempt to modify the resulting buffer
* will cause a {@link java.nio.ReadOnlyBufferException} to be thrown.
* ({@link MapMode#READ_ONLY MapMode.READ_ONLY})
Read/write: 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})
Private: 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})
*
* 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.
*
*
The {@link MappedByteBuffer mapped byte buffer}
* returned by this method will have a position of zero and a limit and
* capacity of size; its mark will be undefined. The buffer and
* the mapping that it represents will remain valid until the buffer itself
* is garbage-collected.
*
*
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.
*
*
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.
*
*
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.
*
* @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
*
* @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 mode is {@link MapMode#READ_ONLY READ_ONLY} but
* this channel was not opened for reading
*
* @throws NonWritableChannelException
* If the mode is {@link MapMode#READ_WRITE READ_WRITE} or
* {@link MapMode#PRIVATE PRIVATE} but this channel was not opened
* for both reading and writing
*
* @throws IllegalArgumentException
* If the preconditions on the parameters do not hold
*
* @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.
*
* 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.
*
*
If this channel is closed by another thread during an invocation of
* this method then an {@link AsynchronousCloseException} will be thrown.
*
*
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.
*
*
The region specified by the position and size
* parameters need not be contained within, or even overlap, the actual
* underlying file. Lock regions are fixed in size; if a locked region
* initially contains the end of the file and the file grows beyond the
* region then the new portion of the file will not be covered by the lock.
* If a file is expected to grow in size and a lock on the entire file is
* required then a region starting at zero, and no smaller than the
* expected maximum size of the file, should be locked. The zero-argument
* {@link #lock()} method simply locks a region of size {@link
* Long#MAX_VALUE}.
*
*
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.
*
*
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.
*
* @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
* position + size must be non-negative
*
* @param shared
* true to request a shared lock, in which case this
* channel must be open for reading (and possibly writing);
* false to request an exclusive lock, in which case this
* channel must be open for writing (and possibly reading)
*
* @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 shared is true this channel was not
* opened for reading
*
* @throws NonWritableChannelException
* If shared is 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.
*
* An invocation of this method of the form fc.lock() behaves
* in exactly the same way as the invocation
*
*
* fc.{@link #lock(long,long,boolean) 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.
*
* 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
* null. If it fails to acquire a lock for any other reason then
* an appropriate exception is thrown.
*
*
The region specified by the position and size
* parameters need not be contained within, or even overlap, the actual
* underlying file. Lock regions are fixed in size; if a locked region
* initially contains the end of the file and the file grows beyond the
* region then the new portion of the file will not be covered by the lock.
* If a file is expected to grow in size and a lock on the entire file is
* required then a region starting at zero, and no smaller than the
* expected maximum size of the file, should be locked. The zero-argument
* {@link #tryLock()} method simply locks a region of size {@link
* Long#MAX_VALUE}.
*
*
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.
*
*
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.
*
* @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
* position + size must be non-negative
*
* @param shared
* true to request a shared lock,
* false to request an exclusive lock
*
* @return A lock object representing the newly-acquired lock,
* or 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.
*
* An invocation of this method of the form fc.tryLock()
* behaves in exactly the same way as the invocation
*
*
* fc.{@link #tryLock(long,long,boolean) tryLock}(0L, Long.MAX_VALUE, false)
*
* @return A lock object representing the newly-acquired lock,
* or 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);
}
}