Interfaz ReadWriteLock en Java

Un bloqueo es un dispositivo para ordenar el acceso a un recurso asignado por múltiples subprocesos. Por lo general, un bloqueo otorga acceso exclusivo a un recurso compartido: solo un subproceso a la vez puede adquirir el bloqueo y todos los que acceden al recurso compartido requieren que el bloqueo se adquiera primero. Sin embargo, algunos bloqueos pueden permitir el acceso en paralelo a un recurso compartido, como el bloqueo de lectura de un ReadWriteLock.

ReadWriteLock es una interfaz. ReadWriteLock se implementa mediante la clase ReentrantReadWriteLock que se encuentra en el paquete java.util.concurrent.locks . Entonces, para usar un ReadWriteLock tenemos que usar ReentrantReadWriteLock.

Una java.util.concurrent.locks.ReadWriteLock es una herramienta de bloqueo de subprocesos de alto nivel. Permite que varios subprocesos lean un recurso específico, pero permite que solo uno lo escriba a la vez.

El enfoque es que varios subprocesos pueden leer desde un recurso compartido sin causar errores de concurrencia. Los errores de simultaneidad ocurren primero cuando las escrituras y las lecturas en un recurso compartido ocurren simultáneamente, o si se realizan varias escrituras simultáneamente.

Normas:

Bloqueo de lectura y bloqueo de escritura que permite que un subproceso bloquee ReadWriteLock para leer o escribir. 

1. Bloqueo de lectura:  si no hay ningún subproceso que haya solicitado el bloqueo de escritura y el bloqueo para escritura, varios subprocesos pueden bloquear el bloqueo para lectura. Significa que varios subprocesos pueden leer los datos en el mismo momento, siempre que no haya un subproceso para escribir los datos o actualizarlos.
2. Bloqueo de escritura:  si ningún subproceso está escribiendo o leyendo, solo un subproceso a la vez puede bloquear el bloqueo para escribir. Otros subprocesos tienen que esperar hasta que se libera el bloqueo. Significa que solo un subproceso puede escribir los datos en el mismo momento, y otros subprocesos tienen que esperar.

Métodos: Hay dos métodos que proporciona ReadWritelock:

1. Bloquear readLock()
2. Bloquear escrituraBloquear()

Su trabajo es similar a su nombre. readLock() utilizado para adquirir el bloqueo durante la lectura:

Lock readLock = rwLock.readLock();

Use el bloqueo de lectura sobre un bloque de código que realiza la operación de lectura:

readLock.lock();
try {
   // statements 
} 
finally {
   readLock.unlock();
}

Y, writeLock() solía adquirir el bloqueo mientras escribía:

Lock writeLock = rwLock.writeLock();

Use el bloqueo de escritura sobre un bloque de código que realiza la operación de escritura:

writeLock.lock();
try {
    statements to write the data
} 
finally {
    writeLock.unlock();
}

Implementación:

// Implementation of ReadWriteLock in Java
import java.io.*;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
class GFG<O> {
  
    private final ReadWriteLock readWriteLock
        = new ReentrantReadWriteLock();
    private final Lock writeLock
        = readWriteLock.writeLock();
    private final Lock readLock = readWriteLock.readLock();
    private final List<O> list = new ArrayList<>();
  
    // setElement function sets
    // i.e., write the element to the thread
    public void setElement(O o)
    {
        // acquire the thread for writing
        writeLock.lock();
        try {
            list.add(o);
            System.out.println(
                "Element by thread "
                + Thread.currentThread().getName()
                + " is added");
        }
        finally {
            // To unlock the acquired write thread
            writeLock.unlock();
        }
    }
  
    // getElement function prints
    // i.e., read the element from the thread
    public O getElement(int i)
    {
        // acquire the thread for reading
        readLock.lock();
        try {
            System.out.println(
                "Elements by thread "
                + Thread.currentThread().getName()
                + " is printed");
            return list.get(i);
        }
        finally {
            // To unlock the acquired read thread
            readLock.unlock();
        }
    }
    public static void main(String[] args)
    {
        GFG<String> gfg = new GFG<>();
  
        gfg.setElement("Hi");
        gfg.setElement("Hey");
        gfg.setElement("Hello");
  
        System.out.println("Printing the last element : "
                           + gfg.getElement(2));
    }
}

Element by thread main is added
Element by thread main is added
Element by thread main is added
Elements by thread main is printed
Printing the last element : Hello