FileChannel Clase tryLock() Método en Java con ejemplos

En el caso de un programa de subprocesos múltiples, donde varios subprocesos se ejecutan al mismo tiempo, necesitamos que se adquieran y liberen bloqueos para mantener la sincronización entre los procesos. FileChannel Class de java también proporciona un método conocido como trylock() que se utiliza para adquirir un bloqueo en el archivo especificado. Este método se utiliza para adquirir un bloqueo en cualquier región del archivo, especificada en los parámetros del método. 

Aquí la salida es el objeto de la clase FileLock que menciona el bloqueo aplicado, si no se aplica ningún bloqueo (tal vez debido a que otros procesos están reteniendo o escribiendo el archivo), entonces este método devolverá un valor nulo. La variable Posición especifica la marca del archivo desde donde se adquirirá el bloqueo y la extensión (hasta la cual se adquirirá el bloqueo) viene dada por la variable ‘tamaño’. Si no se menciona nada en lugar del segundo parámetro, el tamaño de Long.MAX_VALUE se toma por defecto. La variable booleana «compartida» indica si el bloqueo es compartido o no. Si es falso, el bloqueo es exclusivo y se comparte entre otros procesos. Estos son algunos conceptos básicos del método de sincronización. Su valor predeterminado se toma como falso.

La principal ventaja de este método es que nunca se bloqueará. Después de la invocación, devuelve el bloqueo adquirido o devuelve un valor nulo si otro proceso maneja el archivo o genera una excepción. Este método generalmente es diferente del método lock() de la misma clase en el sentido de que en el proceso de sincronización tuvo que esperar mucho para obtener acceso al archivo o recursos y adquirir bloqueos, pero este método nunca esperará y devolverá el valor nulo. o excepción.

Sintaxis: Declaración de método

public abstract FileLock tryLock(long position, long size, boolean shared) throws IOException 

Ejemplo

// Java Program to illustrate FileChannel Class
// tryLock() method
 
// Importing libraries
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.FileLock;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
 
// save the file named as GFG.java
public class GFG extends Thread {
   
    // content to be written in the file.
    String input
        = "geeks for geeks is a learning portal for computer sciences.";
   
    ByteBuffer buf = ByteBuffer.wrap(input.getBytes());
   
    // path of the file
    String fp = "gfg.txt";
   
      // file channel class object
    Path pt = Paths.get(fp);
 
    public void run()
    {
        try {
           
            // the thread says if file is opened.
            FileChannel fc = FileChannel.open(
                pt, StandardOpenOption.WRITE,
                StandardOpenOption.APPEND);
            System.out.println(
                Thread.currentThread().getId()
                + "says:File channel is opened for writing");
           
            // trying lock
            fc.tryLock(0L, Long.MAX_VALUE, false);
            System.out.println(
                Thread.currentThread().getId()
                + "says:acquiring lock");
 
            // writing
            fc.write(buf);
            // release the Lock after writing
            System.out.print(Thread.currentThread().getId()
                             + "says:");
            System.out.println(
                "writing is done, closing the file");
 
            // Closing the file connections
            fc.close();
        }
 
        // Catch block to handle the exception
        catch (Exception e) {
            // Getting and printing current threads
            System.out.println(
                Thread.currentThread().getId()
                + "says: Exception" + e);
        }
 
        // Here, one file raises exception since the file
        // is being written by another thread.
    }
 
    // Main driver method
    public static void main(String[] args) throws Exception
    {
 
        // Creating an object in the main() method
        GFG g1 = new GFG();
        GFG g2 = new GFG();
 
        // Calling start() methods over the objects
        g1.start();
        g2.start();
 
        // Here Two thread in concurrency
        // are trying to access the file
    }
}

Producción:

Salida Explicación:

Estamos creando dos subprocesos que intentarán acceder al archivo y realizar una operación de escritura en él. ya que para mantener la sincronización estamos usando el método trylock() . Cuando uno de los subprocesos adquiere un bloqueo y está realizando una operación en el archivo y luego, si un segundo subproceso llama al bloqueo para adquirirlo, el método genera una excepción ya que el archivo no se puede adquirir libremente. En el código anterior, habíamos adquirido un bloqueo explícito en todo el archivo. Si lo desea, podemos cambiar el tamaño de la parte del archivo en la que se debe adquirir el bloqueo.