OverlappingFileLockException in Java with Examples

// Java Program to Illustrate Shared lock over File

// Importing required classes
import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.channels.FileChannel;
import java.nio.channels.FileLock;
import java.nio.channels.OverlappingFileLockException;

// Main class
// CreateSharedFileLockOnFile
public class GFG {

    // Main driver method
    public static void main(String[] args)
    {

        // Try block to check for exceptions
        try {

            // Creating a file
            File file = new File("fileToLock.dat");

            // Creates a random access file stream to read
            // from, and optionally to write to
            FileChannel channel
                = new RandomAccessFile(file, "rw")
                      .getChannel();

            // Acquire an exclusive lock on this channel's
            // file ( block until the region can be locked,
            // this channel is closed, or the invoking
            // thread is interrupted)
            FileLock lock
                = channel.lock(0, Long.MAX_VALUE, true);

            // Attempts to acquire an exclusive lock on this
            // channel's file (does not block, an invocation
            // always returns immediately, either having
            // acquired a lock on the requested region or
            // having failed to do so.
            try {

                lock = channel.tryLock(0, Long.MAX_VALUE,
                                       true);
            }
            catch (OverlappingFileLockException e) {
                // thrown when an attempt is made to acquire
                // a lock on a a file that overlaps a region
                // already locked by the same JVM or when
                // another thread is already waiting to lock
                // an overlapping region of the same file
                System.out.println(
                    "Overlapping File Lock Error: "
                    + e.getMessage());
            }

            // Checking whether this lock is shared
            boolean isShared = lock.isShared();

            // Releasing the lock
            // using release() method
            lock.release();

            // Closing the channel
            // using standard close() method
            channel.close();
        }

        // Catch block to handle exceptions
        catch (IOException e) {

            // Display message(error) if I/O exception
            // occurs
            System.out.println("I/O Error: "
                               + e.getMessage());
        }
    }
}

// Java Program to Lock a File before Writing into It

// Importing required classes
import java.io.RandomAccessFile;
import java.nio.channels.FileChannel;
import java.nio.channels.FileLock;
import java.nio.channels.OverlappingFileLockException;
import java.util.concurrent.TimeUnit;

// Main class
public class Demo {

    // Main driver method
    public static void main(String[] args) throws Exception
    {
        // Creating object of RandomAccessFile
        RandomAccessFile file
            = new RandomAccessFile("accounts.txt", "rw");

        // Similarly creating object of FileChannel class
        FileChannel channel = file.getChannel();

        // Initially setting lock to file as null
        // as there is no lock by far
        FileLock lock = null;

        // Try block to check for exceptions
        try {
            lock = channel.tryLock();
        }

        // Catch block to handle exceptions
        catch (final OverlappingFileLockException e) {

            // Closing channel and file in order to
            // free up memory resources and avoid leakage
            // using close() method
            file.close();
            channel.close();
        }

        // Writing something while inlocked
        file.writeChars("writing after lock");

        // Making it to sleep for very small amount of time
        TimeUnit.HOURS.sleep(1);

        // Releasig lock over file using release() method
        lock.release();

        // Again closing channel and file in order to
        // free up memory resources and avoid leakage
        // using close() method
        file.close();
        channel.close();
    }
}