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

CKTIS / Java

Lock: adquisición y liberación explícitas de bloqueos

La interfaz java.util.concurrent.locks.Lock permite controlar los bloqueos de forma explícita. Aprende el par lock()/unlock(), el patrón seguro try/finally y un ejemplo que utiliza ReentrantLock para proteger un contador compartido.

Versión: Java SE 21; repository runtime, production runtime not attested

Sintaxis

Lock lock = new ReentrantLock();
lock.lock();
try {
    // protected operations
} finally {
    lock.unlock();
}

java.util.concurrent.locks.Lock es una interfaz para el bloqueo explícito; ReentrantLock es una implementación que proporciona exclusión mutua y permite que el mismo hilo vuelva a entrar. No todas las implementaciones de Lock tienen necesariamente estas propiedades.

Lock.lock() adquiere el bloqueo y espera si es necesario; Lock.unlock() lo libera. Llama a lock.lock() antes de try y a lock.unlock() en finally. A diferencia de synchronized, la liberación no es automática. finally garantiza la liberación incluso si se produce una excepción en el código protegido.

Todos los accesos concurrentes al estado protegido deben seguir el mismo protocolo de bloqueo. Adquirir con éxito el bloqueo desde un hilo que aún no lo posee y liberarlo por completo con éxito tienen los mismos efectos de sincronización de memoria que adquirir y liberar un monitor, respectivamente. Lock no exige esos efectos en las operaciones fallidas ni en las adquisiciones reentrantes y sus liberaciones correspondientes. synchronized (lock) no sustituye a lock.lock().

Con ReentrantLock, cada adquisición necesita una liberación correspondiente; si un hilo que no posee el bloqueo llama a unlock(), se produce IllegalMonitorStateException. La interfaz también ofrece tryLock() y lockInterruptibly() para otras estrategias de espera.

El ejemplo utiliza un único bloqueo compartido para las dos operaciones count++. Después de las dos llamadas a join(), el programa imprime 2, independientemente del orden de ejecución de los hilos. Alcance de la documentación: Java SE 21; no se han confirmado el entorno de ejecución del repositorio ni el de producción.

Ejemplos

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Main {
    private static final Lock lock = new ReentrantLock();
    private static int count = 0;

    private static void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread first = new Thread(Main::increment);
        Thread second = new Thread(Main::increment);
        first.start();
        second.start();
        first.join();
        second.join();
        System.out.println(count);
    }
}

Resultado

2

El código mostrado y el resultado declarado se verificaron en un entorno aislado mediante el método registrado en la evidencia de verificación de esta versión exacta.

Fuentes