1 /*
   2  * Copyright (c) 2007, 2013, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package java.nio.channels;
  27 
  28 import java.nio.file.*;
  29 import java.nio.file.attribute.FileAttribute;
  30 import java.nio.file.spi.*;
  31 import java.nio.ByteBuffer;
  32 import java.io.IOException;
  33 import java.util.concurrent.Future;
  34 import java.util.concurrent.ExecutorService;
  35 import java.util.Set;
  36 import java.util.HashSet;
  37 import java.util.Collections;
  38 
  39 /**
  40  * An asynchronous channel for reading, writing, and manipulating a file.
  41  *
  42  * <p> An asynchronous file channel is created when a file is opened by invoking
  43  * one of the {@link #open open} methods defined by this class. The file contains
  44  * a variable-length sequence of bytes that can be read and written and whose
  45  * current size can be {@link #size() queried}. The size of the file increases
  46  * when bytes are written beyond its  current size; the size of the file decreases
  47  * when it is {@link #truncate truncated}.
  48  *
  49  * <p> An asynchronous file channel does not have a <i>current position</i>
  50  * within the file. Instead, the file position is specified to each read and
  51  * write method that initiates asynchronous operations. A {@link CompletionHandler}
  52  * is specified as a parameter and is invoked to consume the result of the I/O
  53  * operation. This class also defines read and write methods that initiate
  54  * asynchronous operations, returning a {@link Future} to represent the pending
  55  * result of the operation. The {@code Future} may be used to check if the
  56  * operation has completed, wait for its completion, and retrieve the result.
  57  *
  58  * <p> In addition to read and write operations, this class defines the
  59  * following operations: </p>
  60  *
  61  * <ul>
  62  *
  63  *   <li><p> Updates made to a file may be {@link #force <i>forced
  64  *   out</i>} to the underlying storage device, ensuring that data are not
  65  *   lost in the event of a system crash.  </p></li>
  66  *
  67  *   <li><p> A region of a file may be {@link #lock <i>locked</i>} against
  68  *   access by other programs.  </p></li>
  69  *
  70  * </ul>
  71  *
  72  * <p> An {@code AsynchronousFileChannel} is associated with a thread pool to
  73  * which tasks are submitted to handle I/O events and dispatch to completion
  74  * handlers that consume the results of I/O operations on the channel. The
  75  * completion handler for an I/O operation initiated on a channel is guaranteed
  76  * to be invoked by one of the threads in the thread pool (This ensures that the
  77  * completion handler is run by a thread with the expected <em>identity</em>).
  78  * Where an I/O operation completes immediately, and the initiating thread is
  79  * itself a thread in the thread pool, then the completion handler may be invoked
  80  * directly by the initiating thread. When an {@code AsynchronousFileChannel} is
  81  * created without specifying a thread pool then the channel is associated with
  82  * a system-dependent default thread pool that may be shared with other
  83  * channels. The default thread pool is configured by the system properties
  84  * defined by the {@link AsynchronousChannelGroup} class.
  85  *
  86  * <p> Channels of this type are safe for use by multiple concurrent threads. The
  87  * {@link Channel#close close} method may be invoked at any time, as specified
  88  * by the {@link Channel} interface. This causes all outstanding asynchronous
  89  * operations on the channel to complete with the exception {@link
  90  * AsynchronousCloseException}. Multiple read and write operations may be
  91  * outstanding at the same time. When multiple read and write operations are
  92  * outstanding then the ordering of the I/O operations, and the order that the
  93  * completion handlers are invoked, is not specified; they are not, in particular,
  94  * guaranteed to execute in the order that the operations were initiated. The
  95  * {@link java.nio.ByteBuffer ByteBuffers} used when reading or writing are not
  96  * safe for use by multiple concurrent I/O operations. Furthermore, after an I/O
  97  * operation is initiated then care should be taken to ensure that the buffer is
  98  * not accessed until after the operation has completed.
  99  *
 100  * <p> As with {@link FileChannel}, the view of a file provided by an instance of
 101  * this class is guaranteed to be consistent with other views of the same file
 102  * provided by other instances in the same program.  The view provided by an
 103  * instance of this class may or may not, however, be consistent with the views
 104  * seen by other concurrently-running programs due to caching performed by the
 105  * underlying operating system and delays induced by network-filesystem protocols.
 106  * This is true regardless of the language in which these other programs are
 107  * written, and whether they are running on the same machine or on some other
 108  * machine.  The exact nature of any such inconsistencies are system-dependent
 109  * and are therefore unspecified.
 110  *
 111  * @since 1.7
 112  */
 113 
 114 public abstract class AsynchronousFileChannel
 115     implements AsynchronousChannel
 116 {
 117     /**
 118      * Initializes a new instance of this class.
 119      */
 120     protected AsynchronousFileChannel() {
 121     }
 122 
 123     /**
 124      * Opens or creates a file for reading and/or writing, returning an
 125      * asynchronous file channel to access the file.
 126      *
 127      * <p> The {@code options} parameter determines how the file is opened.
 128      * The {@link StandardOpenOption#READ READ} and {@link StandardOpenOption#WRITE
 129      * WRITE} options determines if the file should be opened for reading and/or
 130      * writing. If neither option is contained in the array then an existing file
 131      * is opened for  reading.
 132      *
 133      * <p> In addition to {@code READ} and {@code WRITE}, the following options
 134      * may be present:
 135      *
 136      * <table class="striped">
 137      * <caption style="display:none">additional options</caption>
 138      * <thead>
 139      * <tr> <th>Option</th> <th>Description</th> </tr>
 140      * </thead>
 141      * <tbody>
 142      * <tr>
 143      *   <td> {@link StandardOpenOption#TRUNCATE_EXISTING TRUNCATE_EXISTING} </td>
 144      *   <td> When opening an existing file, the file is first truncated to a
 145      *   size of 0 bytes. This option is ignored when the file is opened only
 146      *   for reading.</td>
 147      * </tr>
 148      * <tr>
 149      *   <td> {@link StandardOpenOption#CREATE_NEW CREATE_NEW} </td>
 150      *   <td> If this option is present then a new file is created, failing if
 151      *   the file already exists. When creating a file the check for the
 152      *   existence of the file and the creation of the file if it does not exist
 153      *   is atomic with respect to other file system operations. This option is
 154      *   ignored when the file is opened only for reading. </td>
 155      * </tr>
 156      * <tr>
 157      *   <td > {@link StandardOpenOption#CREATE CREATE} </td>
 158      *   <td> If this option is present then an existing file is opened if it
 159      *   exists, otherwise a new file is created. When creating a file the check
 160      *   for the existence of the file and the creation of the file if it does
 161      *   not exist is atomic with respect to other file system operations. This
 162      *   option is ignored if the {@code CREATE_NEW} option is also present or
 163      *   the file is opened only for reading. </td>
 164      * </tr>
 165      * <tr>
 166      *   <td > {@link StandardOpenOption#DELETE_ON_CLOSE DELETE_ON_CLOSE} </td>
 167      *   <td> When this option is present then the implementation makes a
 168      *   <em>best effort</em> attempt to delete the file when closed by the
 169      *   the {@link #close close} method. If the {@code close} method is not
 170      *   invoked then a <em>best effort</em> attempt is made to delete the file
 171      *   when the Java virtual machine terminates. </td>
 172      * </tr>
 173      * <tr>
 174      *   <td>{@link StandardOpenOption#SPARSE SPARSE} </td>
 175      *   <td> When creating a new file this option is a <em>hint</em> that the
 176      *   new file will be sparse. This option is ignored when not creating
 177      *   a new file. </td>
 178      * </tr>
 179      * <tr>
 180      *   <td> {@link StandardOpenOption#SYNC SYNC} </td>
 181      *   <td> Requires that every update to the file's content or metadata be
 182      *   written synchronously to the underlying storage device. (see <a
 183      *   href="../file/package-summary.html#integrity"> Synchronized I/O file
 184      *   integrity</a>). </td>
 185      * </tr>
 186      * <tr>
 187      *   <td> {@link StandardOpenOption#DSYNC DSYNC} </td>
 188      *   <td> Requires that every update to the file's content be written
 189      *   synchronously to the underlying storage device. (see <a
 190      *   href="../file/package-summary.html#integrity"> Synchronized I/O file
 191      *   integrity</a>). </td>
 192      * </tr>
 193      * </tbody>
 194      * </table>
 195      *
 196      * <p> An implementation may also support additional options.
 197      *
 198      * <p> The {@code executor} parameter is the {@link ExecutorService} to
 199      * which tasks are submitted to handle I/O events and dispatch completion
 200      * results for operations initiated on resulting channel.
 201      * The nature of these tasks is highly implementation specific and so care
 202      * should be taken when configuring the {@code Executor}. Minimally it
 203      * should support an unbounded work queue and should not run tasks on the
 204      * caller thread of the {@link ExecutorService#execute execute} method.
 205      * Shutting down the executor service while the channel is open results in
 206      * unspecified behavior.
 207      *
 208      * <p> The {@code attrs} parameter is an optional array of file {@link
 209      * FileAttribute file-attributes} to set atomically when creating the file.
 210      *
 211      * <p> The new channel is created by invoking the {@link
 212      * FileSystemProvider#newFileChannel newFileChannel} method on the
 213      * provider that created the {@code Path}.
 214      *
 215      * @param   file
 216      *          The path of the file to open or create
 217      * @param   options
 218      *          Options specifying how the file is opened
 219      * @param   executor
 220      *          The thread pool or {@code null} to associate the channel with
 221      *          the default thread pool
 222      * @param   attrs
 223      *          An optional list of file attributes to set atomically when
 224      *          creating the file
 225      *
 226      * @return  A new asynchronous file channel
 227      *
 228      * @throws  IllegalArgumentException
 229      *          If the set contains an invalid combination of options
 230      * @throws  UnsupportedOperationException
 231      *          If the {@code file} is associated with a provider that does not
 232      *          support creating asynchronous file channels, or an unsupported
 233      *          open option is specified, or the array contains an attribute that
 234      *          cannot be set atomically when creating the file
 235      * @throws  IOException
 236      *          If an I/O error occurs
 237      * @throws  SecurityException
 238      *          If a security manager is installed and it denies an
 239      *          unspecified permission required by the implementation.
 240      *          In the case of the default provider, the {@link
 241      *          SecurityManager#checkRead(String)} method is invoked to check
 242      *          read access if the file is opened for reading. The {@link
 243      *          SecurityManager#checkWrite(String)} method is invoked to check
 244      *          write access if the file is opened for writing
 245      */
 246     public static AsynchronousFileChannel open(Path file,
 247                                                Set<? extends OpenOption> options,
 248                                                ExecutorService executor,
 249                                                FileAttribute<?>... attrs)
 250         throws IOException
 251     {
 252         FileSystemProvider provider = file.getFileSystem().provider();
 253         return provider.newAsynchronousFileChannel(file, options, executor, attrs);
 254     }
 255 
 256     @SuppressWarnings({"unchecked", "rawtypes"}) // generic array construction
 257     private static final FileAttribute<?>[] NO_ATTRIBUTES = new FileAttribute[0];
 258 
 259     /**
 260      * Opens or creates a file for reading and/or writing, returning an
 261      * asynchronous file channel to access the file.
 262      *
 263      * <p> An invocation of this method behaves in exactly the same way as the
 264      * invocation
 265      * <pre>
 266      *     ch.{@link #open(Path,Set,ExecutorService,FileAttribute[])
 267      *       open}(file, opts, null, new FileAttribute&lt;?&gt;[0]);
 268      * </pre>
 269      * where {@code opts} is a {@code Set} containing the options specified to
 270      * this method.
 271      *
 272      * <p> The resulting channel is associated with default thread pool to which
 273      * tasks are submitted to handle I/O events and dispatch to completion
 274      * handlers that consume the result of asynchronous operations performed on
 275      * the resulting channel.
 276      *
 277      * @param   file
 278      *          The path of the file to open or create
 279      * @param   options
 280      *          Options specifying how the file is opened
 281      *
 282      * @return  A new asynchronous file channel
 283      *
 284      * @throws  IllegalArgumentException
 285      *          If the set contains an invalid combination of options
 286      * @throws  UnsupportedOperationException
 287      *          If the {@code file} is associated with a provider that does not
 288      *          support creating file channels, or an unsupported open option is
 289      *          specified
 290      * @throws  IOException
 291      *          If an I/O error occurs
 292      * @throws  SecurityException
 293      *          If a security manager is installed and it denies an
 294      *          unspecified permission required by the implementation.
 295      *          In the case of the default provider, the {@link
 296      *          SecurityManager#checkRead(String)} method is invoked to check
 297      *          read access if the file is opened for reading. The {@link
 298      *          SecurityManager#checkWrite(String)} method is invoked to check
 299      *          write access if the file is opened for writing
 300      */
 301     public static AsynchronousFileChannel open(Path file, OpenOption... options)
 302         throws IOException
 303     {
 304         Set<OpenOption> set = new HashSet<>(options.length);
 305         Collections.addAll(set, options);
 306         return open(file, set, null, NO_ATTRIBUTES);
 307     }
 308 
 309     /**
 310      * Returns the current size of this channel's file.
 311      *
 312      * @return  The current size of this channel's file, measured in bytes
 313      *
 314      * @throws  ClosedChannelException
 315      *          If this channel is closed
 316      * @throws  IOException
 317      *          If some other I/O error occurs
 318      */
 319     public abstract long size() throws IOException;
 320 
 321     /**
 322      * Truncates this channel's file to the given size.
 323      *
 324      * <p> If the given size is less than the file's current size then the file
 325      * is truncated, discarding any bytes beyond the new end of the file.  If
 326      * the given size is greater than or equal to the file's current size then
 327      * the file is not modified. </p>
 328      *
 329      * @param  size
 330      *         The new size, a non-negative byte count
 331      *
 332      * @return  This file channel
 333      *
 334      * @throws  NonWritableChannelException
 335      *          If this channel was not opened for writing
 336      *
 337      * @throws  ClosedChannelException
 338      *          If this channel is closed
 339      *
 340      * @throws  IllegalArgumentException
 341      *          If the new size is negative
 342      *
 343      * @throws  IOException
 344      *          If some other I/O error occurs
 345      */
 346     public abstract AsynchronousFileChannel truncate(long size) throws IOException;
 347 
 348     /**
 349      * Forces any updates to this channel's file to be written to the storage
 350      * device that contains it.
 351      *
 352      * <p> If this channel's file resides on a local storage device then when
 353      * this method returns it is guaranteed that all changes made to the file
 354      * since this channel was created, or since this method was last invoked,
 355      * will have been written to that device.  This is useful for ensuring that
 356      * critical information is not lost in the event of a system crash.
 357      *
 358      * <p> If the file does not reside on a local device then no such guarantee
 359      * is made.
 360      *
 361      * <p> The {@code metaData} parameter can be used to limit the number of
 362      * I/O operations that this method is required to perform.  Passing
 363      * {@code false} for this parameter indicates that only updates to the
 364      * file's content need be written to storage; passing {@code true}
 365      * indicates that updates to both the file's content and metadata must be
 366      * written, which generally requires at least one more I/O operation.
 367      * Whether this parameter actually has any effect is dependent upon the
 368      * underlying operating system and is therefore unspecified.
 369      *
 370      * <p> Invoking this method may cause an I/O operation to occur even if the
 371      * channel was only opened for reading.  Some operating systems, for
 372      * example, maintain a last-access time as part of a file's metadata, and
 373      * this time is updated whenever the file is read.  Whether or not this is
 374      * actually done is system-dependent and is therefore unspecified.
 375      *
 376      * <p> This method is only guaranteed to force changes that were made to
 377      * this channel's file via the methods defined in this class.
 378      *
 379      * @param   metaData
 380      *          If {@code true} then this method is required to force changes
 381      *          to both the file's content and metadata to be written to
 382      *          storage; otherwise, it need only force content changes to be
 383      *          written
 384      *
 385      * @throws  ClosedChannelException
 386      *          If this channel is closed
 387      *
 388      * @throws  IOException
 389      *          If some other I/O error occurs
 390      */
 391     public abstract void force(boolean metaData) throws IOException;
 392 
 393     /**
 394      * Acquires a lock on the given region of this channel's file.
 395      *
 396      * <p> This method initiates an operation to acquire a lock on the given
 397      * region of this channel's file. The {@code handler} parameter is a
 398      * completion handler that is invoked when the lock is acquired (or the
 399      * operation fails). The result passed to the completion handler is the
 400      * resulting {@code FileLock}.
 401      *
 402      * <p> The region specified by the {@code position} and {@code size}
 403      * parameters need not be contained within, or even overlap, the actual
 404      * underlying file.  Lock regions are fixed in size; if a locked region
 405      * initially contains the end of the file and the file grows beyond the
 406      * region then the new portion of the file will not be covered by the lock.
 407      * If a file is expected to grow in size and a lock on the entire file is
 408      * required then a region starting at zero, and no smaller than the
 409      * expected maximum size of the file, should be locked.  The two-argument
 410      * {@link #lock(Object,CompletionHandler)} method simply locks a region
 411      * of size {@link Long#MAX_VALUE}. If a lock that overlaps the requested
 412      * region is already held by this Java virtual machine, or this method has
 413      * been invoked to lock an overlapping region and that operation has not
 414      * completed, then this method throws {@link OverlappingFileLockException}.
 415      *
 416      * <p> Some operating systems do not support a mechanism to acquire a file
 417      * lock in an asynchronous manner. Consequently an implementation may
 418      * acquire the file lock in a background thread or from a task executed by
 419      * a thread in the associated thread pool. If there are many lock operations
 420      * outstanding then it may consume threads in the Java virtual machine for
 421      * indefinite periods.
 422      *
 423      * <p> Some operating systems do not support shared locks, in which case a
 424      * request for a shared lock is automatically converted into a request for
 425      * an exclusive lock.  Whether the newly-acquired lock is shared or
 426      * exclusive may be tested by invoking the resulting lock object's {@link
 427      * FileLock#isShared() isShared} method.
 428      *
 429      * <p> File locks are held on behalf of the entire Java virtual machine.
 430      * They are not suitable for controlling access to a file by multiple
 431      * threads within the same virtual machine.
 432      *
 433      * @param   <A>
 434      *          The type of the attachment
 435      * @param   position
 436      *          The position at which the locked region is to start; must be
 437      *          non-negative
 438      * @param   size
 439      *          The size of the locked region; must be non-negative, and the sum
 440      *          {@code position}&nbsp;+&nbsp;{@code size} must be non-negative
 441      * @param   shared
 442      *          {@code true} to request a shared lock, in which case this
 443      *          channel must be open for reading (and possibly writing);
 444      *          {@code false} to request an exclusive lock, in which case this
 445      *          channel must be open for writing (and possibly reading)
 446      * @param   attachment
 447      *          The object to attach to the I/O operation; can be {@code null}
 448      * @param   handler
 449      *          The handler for consuming the result
 450      *
 451      * @throws  OverlappingFileLockException
 452      *          If a lock that overlaps the requested region is already held by
 453      *          this Java virtual machine, or there is already a pending attempt
 454      *          to lock an overlapping region
 455      * @throws  IllegalArgumentException
 456      *          If the preconditions on the parameters do not hold
 457      * @throws  NonReadableChannelException
 458      *          If {@code shared} is true but this channel was not opened for reading
 459      * @throws  NonWritableChannelException
 460      *          If {@code shared} is false but this channel was not opened for writing
 461      */
 462     public abstract <A> void lock(long position,
 463                                   long size,
 464                                   boolean shared,
 465                                   A attachment,
 466                                   CompletionHandler<FileLock,? super A> handler);
 467 
 468     /**
 469      * Acquires an exclusive lock on this channel's file.
 470      *
 471      * <p> This method initiates an operation to acquire a lock on the given
 472      * region of this channel's file. The {@code handler} parameter is a
 473      * completion handler that is invoked when the lock is acquired (or the
 474      * operation fails). The result passed to the completion handler is the
 475      * resulting {@code FileLock}.
 476      *
 477      * <p> An invocation of this method of the form {@code ch.lock(att,handler)}
 478      * behaves in exactly the same way as the invocation
 479      * <pre>
 480      *     ch.{@link #lock(long,long,boolean,Object,CompletionHandler) lock}(0L, Long.MAX_VALUE, false, att, handler)
 481      * </pre>
 482      *
 483      * @param   <A>
 484      *          The type of the attachment
 485      * @param   attachment
 486      *          The object to attach to the I/O operation; can be {@code null}
 487      * @param   handler
 488      *          The handler for consuming the result
 489      *
 490      * @throws  OverlappingFileLockException
 491      *          If a lock is already held by this Java virtual machine, or there
 492      *          is already a pending attempt to lock a region
 493      * @throws  NonWritableChannelException
 494      *          If this channel was not opened for writing
 495      */
 496     public final <A> void lock(A attachment,
 497                                CompletionHandler<FileLock,? super A> handler)
 498     {
 499         lock(0L, Long.MAX_VALUE, false, attachment, handler);
 500     }
 501 
 502     /**
 503      * Acquires a lock on the given region of this channel's file.
 504      *
 505      * <p> This method initiates an operation to acquire a lock on the given
 506      * region of this channel's file.  The method behaves in exactly the same
 507      * manner as the {@link #lock(long, long, boolean, Object, CompletionHandler)}
 508      * method except that instead of specifying a completion handler, this
 509      * method returns a {@code Future} representing the pending result. The
 510      * {@code Future}'s {@link Future#get() get} method returns the {@link
 511      * FileLock} on successful completion.
 512      *
 513      * @param   position
 514      *          The position at which the locked region is to start; must be
 515      *          non-negative
 516      * @param   size
 517      *          The size of the locked region; must be non-negative, and the sum
 518      *          {@code position}&nbsp;+&nbsp;{@code size} must be non-negative
 519      * @param   shared
 520      *          {@code true} to request a shared lock, in which case this
 521      *          channel must be open for reading (and possibly writing);
 522      *          {@code false} to request an exclusive lock, in which case this
 523      *          channel must be open for writing (and possibly reading)
 524      *
 525      * @return  a {@code Future} object representing the pending result
 526      *
 527      * @throws  OverlappingFileLockException
 528      *          If a lock is already held by this Java virtual machine, or there
 529      *          is already a pending attempt to lock a region
 530      * @throws  IllegalArgumentException
 531      *          If the preconditions on the parameters do not hold
 532      * @throws  NonReadableChannelException
 533      *          If {@code shared} is true but this channel was not opened for reading
 534      * @throws  NonWritableChannelException
 535      *          If {@code shared} is false but this channel was not opened for writing
 536      */
 537     public abstract Future<FileLock> lock(long position, long size, boolean shared);
 538 
 539     /**
 540      * Acquires an exclusive lock on this channel's file.
 541      *
 542      * <p> This method initiates an operation to acquire an exclusive lock on this
 543      * channel's file. The method returns a {@code Future} representing the
 544      * pending result of the operation. The {@code Future}'s {@link Future#get()
 545      * get} method returns the {@link FileLock} on successful completion.
 546      *
 547      * <p> An invocation of this method behaves in exactly the same way as the
 548      * invocation
 549      * <pre>
 550      *     ch.{@link #lock(long,long,boolean) lock}(0L, Long.MAX_VALUE, false)
 551      * </pre>
 552      *
 553      * @return  a {@code Future} object representing the pending result
 554      *
 555      * @throws  OverlappingFileLockException
 556      *          If a lock is already held by this Java virtual machine, or there
 557      *          is already a pending attempt to lock a region
 558      * @throws  NonWritableChannelException
 559      *          If this channel was not opened for writing
 560      */
 561     public final Future<FileLock> lock() {
 562         return lock(0L, Long.MAX_VALUE, false);
 563     }
 564 
 565     /**
 566      * Attempts to acquire a lock on the given region of this channel's file.
 567      *
 568      * <p> This method does not block. An invocation always returns immediately,
 569      * either having acquired a lock on the requested region or having failed to
 570      * do so.  If it fails to acquire a lock because an overlapping lock is held
 571      * by another program then it returns {@code null}.  If it fails to acquire
 572      * a lock for any other reason then an appropriate exception is thrown.
 573      *
 574      * @param  position
 575      *         The position at which the locked region is to start; must be
 576      *         non-negative
 577      *
 578      * @param  size
 579      *         The size of the locked region; must be non-negative, and the sum
 580      *         {@code position}&nbsp;+&nbsp;{@code size} must be non-negative
 581      *
 582      * @param  shared
 583      *         {@code true} to request a shared lock,
 584      *         {@code false} to request an exclusive lock
 585      *
 586      * @return  A lock object representing the newly-acquired lock,
 587      *          or {@code null} if the lock could not be acquired
 588      *          because another program holds an overlapping lock
 589      *
 590      * @throws  IllegalArgumentException
 591      *          If the preconditions on the parameters do not hold
 592      * @throws  ClosedChannelException
 593      *          If this channel is closed
 594      * @throws  OverlappingFileLockException
 595      *          If a lock that overlaps the requested region is already held by
 596      *          this Java virtual machine, or if another thread is already
 597      *          blocked in this method and is attempting to lock an overlapping
 598      *          region of the same file
 599      * @throws  NonReadableChannelException
 600      *          If {@code shared} is true but this channel was not opened for reading
 601      * @throws  NonWritableChannelException
 602      *          If {@code shared} is false but this channel was not opened for writing
 603      *
 604      * @throws  IOException
 605      *          If some other I/O error occurs
 606      *
 607      * @see     #lock(Object,CompletionHandler)
 608      * @see     #lock(long,long,boolean,Object,CompletionHandler)
 609      * @see     #tryLock()
 610      */
 611     public abstract FileLock tryLock(long position, long size, boolean shared)
 612         throws IOException;
 613 
 614     /**
 615      * Attempts to acquire an exclusive lock on this channel's file.
 616      *
 617      * <p> An invocation of this method of the form {@code ch.tryLock()}
 618      * behaves in exactly the same way as the invocation
 619      *
 620      * <pre>
 621      *     ch.{@link #tryLock(long,long,boolean) tryLock}(0L, Long.MAX_VALUE, false) </pre>
 622      *
 623      * @return  A lock object representing the newly-acquired lock,
 624      *          or {@code null} if the lock could not be acquired
 625      *          because another program holds an overlapping lock
 626      *
 627      * @throws  ClosedChannelException
 628      *          If this channel is closed
 629      * @throws  OverlappingFileLockException
 630      *          If a lock that overlaps the requested region is already held by
 631      *          this Java virtual machine, or if another thread is already
 632      *          blocked in this method and is attempting to lock an overlapping
 633      *          region
 634      * @throws  NonWritableChannelException
 635      *          If {@code shared} is false but this channel was not opened for writing
 636      *
 637      * @throws  IOException
 638      *          If some other I/O error occurs
 639      *
 640      * @see     #lock(Object,CompletionHandler)
 641      * @see     #lock(long,long,boolean,Object,CompletionHandler)
 642      * @see     #tryLock(long,long,boolean)
 643      */
 644     public final FileLock tryLock() throws IOException {
 645         return tryLock(0L, Long.MAX_VALUE, false);
 646     }
 647 
 648     /**
 649      * Reads a sequence of bytes from this channel into the given buffer,
 650      * starting at the given file position.
 651      *
 652      * <p> This method initiates the reading of a sequence of bytes from this
 653      * channel into the given buffer, starting at the given file position. The
 654      * result of the read is the number of bytes read or {@code -1} if the given
 655      * position is greater than or equal to the file's size at the time that the
 656      * read is attempted.
 657      *
 658      * <p> This method works in the same manner as the {@link
 659      * AsynchronousByteChannel#read(ByteBuffer,Object,CompletionHandler)}
 660      * method, except that bytes are read starting at the given file position.
 661      * If the given file position is greater than the file's size at the time
 662      * that the read is attempted then no bytes are read.
 663      *
 664      * @param   <A>
 665      *          The type of the attachment
 666      * @param   dst
 667      *          The buffer into which bytes are to be transferred
 668      * @param   position
 669      *          The file position at which the transfer is to begin;
 670      *          must be non-negative
 671      * @param   attachment
 672      *          The object to attach to the I/O operation; can be {@code null}
 673      * @param   handler
 674      *          The handler for consuming the result
 675      *
 676      * @throws  IllegalArgumentException
 677      *          If the position is negative or the buffer is read-only
 678      * @throws  NonReadableChannelException
 679      *          If this channel was not opened for reading
 680      */
 681     public abstract <A> void read(ByteBuffer dst,
 682                                   long position,
 683                                   A attachment,
 684                                   CompletionHandler<Integer,? super A> handler);
 685 
 686     /**
 687      * Reads a sequence of bytes from this channel into the given buffer,
 688      * starting at the given file position.
 689      *
 690      * <p> This method initiates the reading of a sequence of bytes from this
 691      * channel into the given buffer, starting at the given file position. This
 692      * method returns a {@code Future} representing the pending result of the
 693      * operation. The {@code Future}'s {@link Future#get() get} method returns
 694      * the number of bytes read or {@code -1} if the given position is greater
 695      * than or equal to the file's size at the time that the read is attempted.
 696      *
 697      * <p> This method works in the same manner as the {@link
 698      * AsynchronousByteChannel#read(ByteBuffer)} method, except that bytes are
 699      * read starting at the given file position. If the given file position is
 700      * greater than the file's size at the time that the read is attempted then
 701      * no bytes are read.
 702      *
 703      * @param   dst
 704      *          The buffer into which bytes are to be transferred
 705      * @param   position
 706      *          The file position at which the transfer is to begin;
 707      *          must be non-negative
 708      *
 709      * @return  A {@code Future} object representing the pending result
 710      *
 711      * @throws  IllegalArgumentException
 712      *          If the position is negative or the buffer is read-only
 713      * @throws  NonReadableChannelException
 714      *          If this channel was not opened for reading
 715      */
 716     public abstract Future<Integer> read(ByteBuffer dst, long position);
 717 
 718     /**
 719      * Writes a sequence of bytes to this channel from the given buffer, starting
 720      * at the given file position.
 721      *
 722      * <p> This method works in the same manner as the {@link
 723      * AsynchronousByteChannel#write(ByteBuffer,Object,CompletionHandler)}
 724      * method, except that bytes are written starting at the given file position.
 725      * If the given position is greater than the file's size, at the time that
 726      * the write is attempted, then the file will be grown to accommodate the new
 727      * bytes; the values of any bytes between the previous end-of-file and the
 728      * newly-written bytes are unspecified.
 729      *
 730      * @param   <A>
 731      *          The type of the attachment
 732      * @param   src
 733      *          The buffer from which bytes are to be transferred
 734      * @param   position
 735      *          The file position at which the transfer is to begin;
 736      *          must be non-negative
 737      * @param   attachment
 738      *          The object to attach to the I/O operation; can be {@code null}
 739      * @param   handler
 740      *          The handler for consuming the result
 741      *
 742      * @throws  IllegalArgumentException
 743      *          If the position is negative
 744      * @throws  NonWritableChannelException
 745      *          If this channel was not opened for writing
 746      */
 747     public abstract <A> void write(ByteBuffer src,
 748                                    long position,
 749                                    A attachment,
 750                                    CompletionHandler<Integer,? super A> handler);
 751 
 752     /**
 753      * Writes a sequence of bytes to this channel from the given buffer, starting
 754      * at the given file position.
 755      *
 756      * <p> This method initiates the writing of a sequence of bytes to this
 757      * channel from the given buffer, starting at the given file position. The
 758      * method returns a {@code Future} representing the pending result of the
 759      * write operation. The {@code Future}'s {@link Future#get() get} method
 760      * returns the number of bytes written.
 761      *
 762      * <p> This method works in the same manner as the {@link
 763      * AsynchronousByteChannel#write(ByteBuffer)} method, except that bytes are
 764      * written starting at the given file position. If the given position is
 765      * greater than the file's size, at the time that the write is attempted,
 766      * then the file will be grown to accommodate the new bytes; the values of
 767      * any bytes between the previous end-of-file and the newly-written bytes
 768      * are unspecified.
 769      *
 770      * @param   src
 771      *          The buffer from which bytes are to be transferred
 772      * @param   position
 773      *          The file position at which the transfer is to begin;
 774      *          must be non-negative
 775      *
 776      * @return  A {@code Future} object representing the pending result
 777      *
 778      * @throws  IllegalArgumentException
 779      *          If the position is negative
 780      * @throws  NonWritableChannelException
 781      *          If this channel was not opened for writing
 782      */
 783     public abstract Future<Integer> write(ByteBuffer src, long position);
 784 }