FileChannel.java

/*
 * 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.IOException;
import java.nio.ByteBuffer;
import java.nio.MappedByteBuffer;
import java.nio.channels.spi.AbstractInterruptibleChannel;
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.Collections;
import java.util.HashSet;
import java.util.Set;

/**
 * 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
 */
/*
 * 文件通道
 *
 * FileChannel总是阻塞式的，它不能被置于非阻塞模式
 * FileChannel对象不能直接创建，它只能通过在一个打开的File(RandomAccessFile、FileInputStream或FileOutputStream)上调用getChannel()方法获取
 * 调用getChannel()方法会返回一个连接到相同文件的FileChannel对象，且该FileChannel对象具有与file对象相同的访问权限，即从输出流得到的可写通道，从输入流得到的可读通道
 *
 * 一般来源：
 * FileInputStream#getChannel()，只读通道
 * FileOutputStream#getChannel()，只写通道
 * RandomAccessFile#getChannel()，读写通道
 * FileChannel内的工厂方法
 */
public abstract class FileChannel extends AbstractInterruptibleChannel implements SeekableByteChannel, GatheringByteChannel, ScatteringByteChannel {
    
    // 指示没有设置文件属性
    @SuppressWarnings({"unchecked", "rawtypes"})
    private static final FileAttribute<?>[] NO_ATTRIBUTES = new FileAttribute[0];
    
    
    
    /*▼ 构造器 ████████████████████████████████████████████████████████████████████████████████┓ */
    
    /**
     * Initializes a new instance of this class.
     */
    protected FileChannel() {
    }
    
    /*▲ 构造器 ████████████████████████████████████████████████████████████████████████████████┛ */
    
    
    
    /*▼ 工厂方法 ████████████████████████████████████████████████████████████████████████████████┓ */
    
    /**
     * 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&lt;?&gt;[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
     */
    // 创建一个文件通道，options指示创建参数，默认是只读通道
    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);
    }
    
    /**
     * 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
     */
    /*
     * 创建一个文件通道；options指示创建参数，默认是只读通道，attrs指示文件属性
     *
     * 注：attrs是文件权限属性，允许为空数组(默认)，但不能为null，其实现依平台实现而定：
     * windows  : 要求attrs的name()方法返回"acl:acl"，且value()方法返回List<AclEntry>类型的对象
     * linux/mac: 要求attrs的name()方法返回"posix:permissions"或"unix:permissions"，且value()方法返回Set<PosixFilePermission>类型的对象
     */
    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);
    }
    
    /*▲ 工厂方法 ████████████████████████████████████████████████████████████████████████████████┛ */
    
    
    
    /*▼ 读 ████████████████████████████████████████████████████████████████████████████████┓ */
    
    /**
     * 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>
     */
    /*
     * 从当前文件通道(关联的文件)中起始处读取，读到的内容存入dst后，返回读到的字节数量
     * 该方法是一次性地，即已经读完的流不可以重复读取
     */
    public abstract int read(ByteBuffer dst) 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 {@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
     */
    /*
     * 从当前文件通道(关联的文件)中读取，读到的内容存入dst后，返回读到的字节数量
     * 该方法可重复调用(因为position>=0)，读取的位置是position指定的位置(支持随机读取)
     */
    public abstract int read(ByteBuffer dst, long position) 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>
     */
    /*
     * 从当前文件通道(关联的文件)中读取，读到的内容依次存入dsts中各个缓冲区后，返回读到的字节数量
     * 该方法是一次性地，即已经读完的流不可以重复读取(不支持随机读取)
     */
    public final long read(ByteBuffer[] dsts) throws IOException {
        return read(dsts, 0, dsts.length);
    }
    
    /**
     * 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>
     */
    /*
     * 从当前文件通道(关联的文件)中读取，读到的内容依次存入dsts中offset处起的length个缓冲区后，返回读到的字节数量
     * 该方法是一次性地，即已经读完的流不可以重复读取(不支持随机读取)
     */
    public abstract long read(ByteBuffer[] dsts, int offset, int length) throws IOException;
    
    /*▲ 读 ████████████████████████████████████████████████████████████████████████████████┛ */
    
    
    
    /*▼ 写 ████████████████████████████████████████████████████████████████████████████████┓ */
    
    /**
     * 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>
     */
    /*
     * 从缓冲区src读取，读到的内容向当前文件通道(关联的文件)中追加写入后，返回写入的字节数量
     * 待写入内容从fd中上次position==-1时写完的末尾追加内容(不支持随机写入)
     */
    public abstract int write(ByteBuffer src) 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
     */
    /*
     * 从缓冲区src读取，读到的内容向当前文件通道(关联的文件)中position位置处写入后，返回写入的字节数量
     * 待写入内容从fd的position位置处开始写(支持随机写入)
     */
    public abstract int write(ByteBuffer src, long position) 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>
     */
    // 从srcs中各个缓冲区读取，读到内容向当前文件通道(关联的文件)中起始位置处写入，返回写入的字节数量
    public final long write(ByteBuffer[] srcs) throws IOException {
        return write(srcs, 0, srcs.length);
    }
    
    /**
     * 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>
     */
    // 从srcs[offset, offset+length-1]中各个缓冲区读取，读到内容向当前文件通道(关联的文件)中起始位置处写入，返回写入的字节数量
    public abstract long write(ByteBuffer[] srcs, int offset, int length) 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
     */
    // 发送：从当前文件通道的position位置起读取count个字节的数据(数量会经过修正)，读到的数据会写入target通道，要求当前文件通道可读，目标通道可写；返回实际传输的字节数量。
    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
     */
    // 接收：从源通道src中起始位置处读取count个字节，读到的数据写入当前文件通道的position位置，要求源通道可读，当前文件通道可写；返回实际接收的字节数量。
    public abstract long transferFrom(ReadableByteChannel src, long position, long count) throws IOException;
    
    /*▲ 传输数据 ████████████████████████████████████████████████████████████████████████████████┛ */
    
    
    
    /*▼ 内存映射 ████████████████████████████████████████████████████████████████████████████████┓ */
    
    /**
     * Maps a region of this channel's file directly into memory.
     *
     * <p> A region of a file may be mapped into memory in one of three modes:
     * </p>
     *
     * <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> 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
     * @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} but
     *                                     this channel was not opened for reading
     * @throws NonWritableChannelException If the {@code 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
     */
    /*
     * 返回一块文件映射内存(经过了包装，加入了内存清理操作)
     *
     * 例如映射整个通道的内容，可以调用：
     * fileChannel.map(FileChannel.MapMode.READ_ONLY, 0, fileChannel.size());
     *
     * 与文件锁的范围机制不一样，映射文件的范围不应超过文件的实际大小。
     * 如果申请一个超出文件大小的映射，文件会被增大以匹配映射的大小
     *
     * 注：
     * 同锁不一样的是，映射缓冲区没有绑定到创建它们的通道上
     * 关闭相关联的FileChannel不会破坏映射，只有丢弃缓冲区对象本身才会破坏该映射
     */
    public abstract MappedByteBuffer map(MapMode mode, long position, long size) throws IOException;
    
    /*▲ 内存映射 ████████████████████████████████████████████████████████████████████████████████┛ */
    
    
    
    /*▼ 文件锁 ████████████████████████████████████████████████████████████████████████████████┓ */
    
    /**
     * 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}&nbsp;+&nbsp;{@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;
    
    /**
     * 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}&nbsp;+&nbsp;{@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;
    
    /**
     * 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 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);
    }
    
    /*▲ 文件锁 ████████████████████████████████████████████████████████████████████████████████┛ */
    
    
    
    /*▼ 通道操作 ████████████████████████████████████████████████████████████████████████████████┓ */
    
    /**
     * 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
     */
    // 用指定的新尺寸size截断通道(文件)
    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
     */
    /*
     * 设置更新文件内容时，是否实时同步其元数据
     * metaData为true 时，将文件内容或元数据的每个更新都实时同步到底层设备，类似于RandomAccessFile的rws模式
     * metaData为false时，将文件内容的每个更新都实时同步到底层设备，类似于RandomAccessFile的rwd模式
     */
    public abstract void force(boolean metaData) throws IOException;
    
    /*▲ 通道操作 ████████████████████████████████████████████████████████████████████████████████┛ */
    
    
    /**
     * A typesafe enumeration for file-mapping modes.
     *
     * @see java.nio.channels.FileChannel#map
     * @since 1.4
     */
    // 内存映射模式
    public static class MapMode {
        
        /**
         * Mode for a read-only mapping.
         */
        /*
         * 只读映射(需要通道支持read模式)
         * 在当前模式下，只能从通道中读取内容
         *
         * 例如：
         * FileInputStream关联的通道的映射
         * "r"模式或"rw"模式下的RandomAccessFile关联的通道的映射
         */
        public static final MapMode READ_ONLY = new MapMode("READ_ONLY");
        
        /**
         * Mode for a read/write mapping.
         */
        /*
         * 读写映射(需要通道支持read-write模式)
         * 在当前模式下，可以从通道中读取内容，也可以向通道中写入内容，并刷新到文件中
         *
         * 例如：
         * "rw"模式下的RandomAccessFile关联的通道的映射
         */
        public static final MapMode READ_WRITE = new MapMode("READ_WRITE");
        
        /**
         * Mode for a private (copy-on-write) mapping.
         */
        /*
         * 写时拷贝映射(需要通道支持read-write模式)
         * 在当前模式下，可以从通道中读取内容，但是向通道中写入内容时，该内容并不会刷新到文件中
         *
         * 例如：
         * "rw"模式下的RandomAccessFile关联的通道的映射
         */
        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;
        }
    }
    
}