Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / Java

Bloqueo de lectura y escritura: readLock(), writeLock(), lock() y unlock()

Varios hilos pueden leer datos compartidos a la vez, pero escribir requiere acceso exclusivo. Elegir un bloqueo no equivale a adquirirlo.

Versión: Java SE 21

Sintaxis

// java.util.concurrent.locks.ReadWriteLock
Lock readLock();
Lock writeLock();

// java.util.concurrent.locks.Lock
void lock();
void unlock();

En Java SE 21, ReadWriteLock y Lock son interfaces del paquete java.util.concurrent.locks. readLock() y writeLock() devuelven los objetos Lock asociados, pero no adquieren los bloqueos. Usa una misma instancia de ReadWriteLock para proteger el estado compartido: el bloqueo de lectura para las operaciones que no modifican nada y el de escritura para los cambios. Varios hilos pueden mantener a la vez el bloqueo de lectura. Mientras un hilo mantiene el de escritura, ningún otro puede adquirir ninguno de los dos.

lock() y unlock() no reciben argumentos y devuelven void. Llama a lock() antes del bloque try: si el bloqueo no está disponible, el hilo espera hasta adquirirlo. Llama a unlock() sobre el mismo Lock en finally para liberarlo aunque el código protegido lance una excepción. El ejemplo usa tryLock() sin argumentos, que no espera: devuelve true si adquirió el bloqueo y false si no. Libera el bloqueo solo si lo adquiriste correctamente.

Una vez liberado el bloqueo de escritura, un hilo que después adquiere el bloqueo de lectura asociado ve los cambios hechos bajo el bloqueo de escritura. Los bloqueos no protegen al código que accede al estado sin usarlos.

Con ReentrantReadWriteLock, el hilo debe compensar cada adquisición con un unlock(). Si libera un bloqueo que no mantiene, se lanza IllegalMonitorStateException. No intentes adquirir el bloqueo de escritura si solo mantienes el de lectura: lock() no regresará. Libera el de lectura, adquiere el de escritura y vuelve a comprobar el estado, porque puede haber cambiado entre tanto. En sentido contrario, puedes adquirir el de lectura mientras aún mantienes el de escritura y luego liberar el de escritura.

Ejemplos

import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockDemo {
    private final ReadWriteLock rw = new ReentrantReadWriteLock();
    private final Lock read = rw.readLock();
    private final Lock write = rw.writeLock();
    private int value = 0;

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        new ReadWriteLockDemo().run();
    }

    private void run() throws InterruptedException, ExecutionException {
        read.lock();
        try {
            System.out.println("read lock held: " + probeFromAnotherThread());
        } finally {
            read.unlock();
        }

        write.lock();
        try {
            value = 10;
            System.out.println("write lock held: " + probeFromAnotherThread());
        } finally {
            write.unlock();
        }

        int snapshot;
        read.lock();
        try {
            snapshot = value;
        } finally {
            read.unlock();
        }
        System.out.println("read after write: " + snapshot);
    }

    private String probeFromAnotherThread() throws InterruptedException, ExecutionException {
        FutureTask<String> probe = new FutureTask<>(() -> {
            String snapshot = "blocked";
            if (read.tryLock()) {
                try {
                    snapshot = Integer.toString(value);
                } finally {
                    read.unlock();
                }
            }
            return "reader=" + snapshot + ", writer=" + canAcquireNow(write);
        });
        new Thread(probe).start();
        return probe.get();
    }

    private static boolean canAcquireNow(Lock lock) {
        if (!lock.tryLock()) {
            return false;
        }
        try {
            return true;
        } finally {
            lock.unlock();
        }
    }
}

Resultado

read lock held: reader=0, writer=false
write lock held: reader=blocked, writer=false
read after write: 10

Mientras el hilo principal mantiene el bloqueo de lectura, un segundo hilo lee `0`, pero no puede adquirir el bloqueo de escritura. Tras asignar `10`, mientras el hilo principal aún mantiene el bloqueo de escritura, los dos intentos del segundo hilo fallan. Al liberarse el bloqueo de escritura, una lectura protegida obtiene `10`. `FutureTask.get()` mantiene ese orden sin introducir pausas.

Lecciones relacionadas

  • Java · Lección 29 · Avanzado · Versión: 2

Fuentes