OverlappingFileLockException en Java con ejemplos

Se lanza una excepción OverlappingFileLockException cuando se intenta adquirir un bloqueo que se superpone a un bloqueo existente o pendiente retenido por este proceso.

Esta excepción es lanzada por los métodos lock( ) y tryLock( ) de FileChannel si la región de bloqueo solicitada se superpone a un bloqueo de archivo que ya tiene algún subproceso en esta JVM, o si ya hay un subproceso en esta JVM esperando para bloquear un región superpuesta del mismo archivo. El mecanismo de bloqueo de archivos FileChannel está diseñado para bloquear archivos contra el acceso simultáneo de dos procesos separados. Dos subprocesos dentro de la misma JVM no deben intentar adquirir un bloqueo en regiones superpuestas del mismo archivo, y cualquier intento de hacerlo provoca que se genere una excepción de este tipo.

Vista del paquete

java.lang.Object
    java.lang.Throwable
         java.lang.Exception
              java.lang.RuntimeException
                   java.lang.IllegalStateException
                    java.nio.channels.OverlappingFileLockException

Recuerde: implementa la interfaz Serializable .

Sintaxis:

public class OverlappingFileLockException
extends IllegalStateException

Nota: Se lanza una excepción no verificada cuando se intenta adquirir un bloqueo en una región de un archivo que se superpone a una región ya bloqueada por la misma máquina virtual Java, o cuando otro subproceso ya está esperando para bloquear una región superpuesta del mismo. expediente.

Resumen del constructor

• OverlappingFileLockException(): construye una instancia de esta clase.

Implementación:

En este ejemplo, le mostraremos cómo crear un bloqueo de archivo compartido en Java y manejar OverlappingFileLockException. La creación de bloqueos de archivos compartidos utilizando Java NIO Channels implica que uno debe:

1. Cree un objeto de archivo para encapsular un archivo real en el sistema de archivos que desea bloquear
2. Cree una secuencia de archivos de acceso aleatorio (lectura-escritura). Para hacerlo, primero debe crear un objeto RandomAccessFile para encapsular el objeto de archivo creado anteriormente y abrirlo para operaciones de lectura y escritura. Luego use el método API getChannel() del objeto RandomAccessFile para obtener el canal de archivo para leer/escribir datos desde/hacia
3. Adquiera un bloqueo exclusivo en el archivo de este canal utilizando el método API lock(long, long, boolean) de la clase FileChannel. Este método bloquea hasta que se puede bloquear la región o se cierra este canal o se interrumpe el subproceso de invocación. El atributo booleano marca el bloqueo como compartido o no. El método devuelve un identificador a una clase FileLock para utilizar el bloqueo
4. Alternativamente, podríamos usar el método API tryLock(long, long, boolean) de la clase FileChannel. Este método intenta adquirir un bloqueo exclusivo en el archivo de este canal pero no bloquea; una invocación siempre regresa de inmediato, ya sea que haya adquirido un bloqueo en la región solicitada o que no lo haya logrado.

Ejemplo 1

// 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());
        }
    }
}

Producción:

Ejemplo 2:

// 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();
    }
}

Producción:

Lanzará OverlappingFileLockException, si esta máquina virtual Java ya tiene un bloqueo que se superpone a la región solicitada, o si otro subproceso ya está bloqueado en este método e intenta bloquear una región superpuesta.