Demonstrates file locking and simple file read and write operations using java.nio.channels.FileChannel : FileChannel « File Input Output « Java

Demonstrates file locking and simple file read and write operations using java.nio.channels.FileChannel

 * Copyright (c) 2004 David Flanagan.  All rights reserved.
 * This code is from the book Java Examples in a Nutshell, 3nd Edition.
 * It is provided AS-IS, WITHOUT ANY WARRANTY either expressed or implied.
 * You may study, use, and modify it for any non-commercial purpose,
 * including teaching and use in open-source projects.
 * You may distribute it non-commercially as long as you retain this notice.
 * For a commercial use license, or to purchase the book, 
 * please visit
//package je3.nio;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.FileLock;

 * this class demonstrates file locking and simple file read and
 * write operations using java.nio.channels.FileChannel. It uses file locking to
 * prevent two instances of the program from running at the same time.
public class Lock {
  public static void main(String args[]) throws IOException, InterruptedException {
    RandomAccessFile file = null; // The file we'll lock
    FileChannel f = null; // The channel to the file
    FileLock lock = null; // The lock object we hold

    try { // The finally clause closes the channel and releases the lock
      // We use a temporary file as the lock file.
      String tmpdir = System.getProperty("");
      String filename = Lock.class.getName() + ".lock";
      File lockfile = new File(tmpdir, filename);

      // Create a FileChannel that can read and write that file.
      // Note that we rely on the package to open the file,
      // in read/write mode, and then just get a channel from it.
      // This will create the file if it doesn't exit. We'll arrange
      // for it to be deleted below, if we succeed in locking it.
      file = new RandomAccessFile(lockfile, "rw");
      f = file.getChannel();

      // Try to get an exclusive lock on the file.
      // This method will return a lock or null, but will not block.
      // See also FileChannel.lock() for a blocking variant.
      lock = f.tryLock();

      if (lock != null) {
        // We obtained the lock, so arrange to delete the file when
        // we're done, and then write the approximate time at which
        // we'll relinquish the lock into the file.
        lockfile.deleteOnExit(); // Just a temporary file

        // First, we need a buffer to hold the timestamp
        ByteBuffer bytes = ByteBuffer.allocate(8); // a long is 8 bytes

        // Put the time in the buffer and flip to prepare for writing
        // Note that many Buffer methods can be "chained" like this.
        bytes.putLong(System.currentTimeMillis() + 10000).flip();

        f.write(bytes); // Write the buffer contents to the channel
        f.force(false); // Force them out to the disk
      } else {
        // We didn't get the lock, which means another instance is
        // running. First, let the user know this.
        System.out.println("Another instance is already running");

        // Next, we attempt to read the file to figure out how much
        // longer the other instance will be running. Since we don't
        // have a lock, the read may fail or return inconsistent data.
        try {
          ByteBuffer bytes = ByteBuffer.allocate(8);
; // Read 8 bytes from the file
          bytes.flip(); // Flip buffer before extracting bytes
          long exittime = bytes.getLong(); // Read bytes as a long
          // Figure out how long that time is from now and round
          // it to the nearest second.
          long secs = (exittime - System.currentTimeMillis() + 500) / 1000;
          // And tell the user about it.
          System.out.println("Try again in about " + secs + " seconds");
        } catch (IOException e) {
          // This probably means that locking is enforced by the OS
          // and we were prevented from reading the file.

        // This is an abnormal exit, so set an exit code.

      // Simulate a real application by sleeping for 10 seconds.
    } finally {
      // Always release the lock and close the file
      // Closing the RandomAccessFile also closes its FileChannel.
      if (lock != null && lock.isValid())
      if (file != null)


Related examples in the same category

1.Performs a straightforward copy operation
2.Write to a file using FileChannel.
3.Using FileChannels to Access a File
4.Write to a mapped file.
5.Copy a file using NIO.
6.Get FileChannel from FileOutputStream and FileInputStream
7.Transfer between FileChannel
8.Read bytes from the specified channel, decode them using the specified Charset, and write the resulting characters to the specified writer
9.Create a read-only memory-mapped file
10.Create a read-write memory-mapped file
11.Creating a Stream from a Channel
12.Create an inputstream on the channel
13.Create a private (copy-on-write) memory-mapped file.
14.A character output stream that sends output to a printer
15.Write file with FileChannel
16.Read file with FileChannel
17.Copy ALL available data from one stream into another with Channel
18.Copy file with FileChannel