CKTIS / Java
Métodos de ReentrantLock: adquisición, reentrada y condiciones
Distingue el `lock()` bloqueante de las dos sobrecargas de `tryLock()`, compensa cada adquisición con `unlock()` y usa condiciones distintas en un mismo bloqueo.
Versión: Java SE 21
Sintaxis
// Java SE 21 — instance methods of java.util.concurrent.locks.ReentrantLock
public void lock()
public void unlock()
public boolean tryLock()
public boolean tryLock(long timeout, java.util.concurrent.TimeUnit unit) throws InterruptedException
public java.util.concurrent.locks.Condition newCondition()
public int getHoldCount()En Java SE 21, java.util.concurrent.locks.ReentrantLock es un bloqueo reentrante de exclusión mutua. lock() espera si otro hilo posee el bloqueo; una interrupción no cancela esa espera. El propietario puede adquirir de nuevo el mismo bloqueo sin esperar. getHoldCount() cuenta las adquisiciones pendientes de liberar del hilo actual, no los hilos en espera; 0 no significa que el bloqueo esté libre.
unlock() resta uno al contador y libera el bloqueo solo cuando llega a 0. Si lo llama un hilo que no posee el bloqueo, lanza IllegalMonitorStateException. Entra en un try justo después de cada adquisición exitosa y pon el unlock() correspondiente en finally. No liberes el bloqueo por un intento fallido o que lanzó una excepción. Si el código necesita ambos bloqueos, adquiérelos siempre en el mismo orden, por ejemplo gateLock antes de orderLock, y libéralos en orden inverso.
tryLock() no espera: devuelve false si otro hilo posee el bloqueo y true si lo adquiere, también por reentrada. Puede adelantarse a los hilos en cola incluso con un bloqueo equitativo. tryLock(timeout, unit) respeta la política de equidad si está habilitada, espera como máximo el tiempo especificado (timeout <= 0 significa que no espera) y devuelve false si no lo adquiere en ese plazo. Una interrupción al entrar o durante la adquisición provoca InterruptedException y borra el estado de interrupción; unit == null no es válido y provoca NullPointerException.
Cada llamada a newCondition() crea un objeto Condition distinto asociado al mismo bloqueo. En un búfer de una plaza, notEmpty es para los consumidores y notFull para los productores. Llamar a signal() sin poseer ese bloqueo provoca IllegalMonitorStateException. await() comprueba primero el estado de interrupción del hilo actual. Si el hilo ya está interrumpido, await() borra ese estado y lanza InterruptedException antes de comprobar si el hilo posee el bloqueo y sin liberarlo. De lo contrario, await() lanza IllegalMonitorStateException si el hilo no posee el bloqueo. Si pasa a esperar, await() libera el bloqueo de forma atómica y lo readquiere con el contador original antes de que termine la llamada. Comprueba el estado en un bucle while porque puede haber despertares espurios. Señaliza después de cambiar el estado, sin soltar el bloqueo; signal() no lo libera.
Ejemplos
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
public class Main {
private static final class Slot {
private final ReentrantLock lock = new ReentrantLock();
private final Condition notEmpty = lock.newCondition();
private final Condition notFull = lock.newCondition();
private Integer value;
void put(int item) throws InterruptedException {
lock.lock();
try {
while (value != null) {
notFull.await();
}
value = item;
notEmpty.signal();
} finally {
lock.unlock();
}
}
int take() throws InterruptedException {
lock.lock();
try {
while (value == null) {
notEmpty.await();
}
int item = value;
value = null;
notFull.signal();
return item;
} finally {
lock.unlock();
}
}
}
public static void main(String[] args) throws InterruptedException {
ReentrantLock gateLock = new ReentrantLock();
ReentrantLock orderLock = new ReentrantLock(true);
System.out.println(orderLock.getHoldCount());
orderLock.lock();
try {
orderLock.lock();
try {
System.out.println(orderLock.getHoldCount());
} finally {
orderLock.unlock();
}
System.out.println(orderLock.getHoldCount());
if (orderLock.tryLock()) {
try {
System.out.println(orderLock.getHoldCount());
} finally {
orderLock.unlock();
}
}
System.out.println(orderLock.getHoldCount());
} finally {
orderLock.unlock();
}
System.out.println(orderLock.getHoldCount());
gateLock.lock();
try {
for (int attempt = 1; attempt <= 2; attempt++) {
if (!orderLock.tryLock(10, TimeUnit.MILLISECONDS)) {
System.out.println("timed " + attempt + ": timeout");
continue;
}
try {
System.out.println("timed " + attempt + ": acquired");
} finally {
orderLock.unlock();
}
}
} finally {
gateLock.unlock();
}
Slot slot = new Slot();
slot.put(42);
System.out.println("slot: " + slot.take());
}
}Resultado
0 2 1 2 1 0 timed 1: acquired timed 2: acquired slot: 42
Dos llamadas a `lock()` dan el primer `2` tras el `0` inicial. Un `unlock()` deja `1`, y el `tryLock()` inmediato del propietario vuelve a dar `2`. Las dos liberaciones restantes dejan `1` y `0`. Ambos intentos con plazo se hacen sobre el mismo `orderLock` y tienen éxito sin contención. `put(42)` y `take()` usan condiciones distintas del único bloqueo del búfer; ninguna operación espera en esta ejecución.
Lecciones relacionadas
- Java · Lección 30 · Avanzado · Versión: 2
- Java · Lección 54 · Intermedio · Versión: 2
- Java · Lección 58 · Intermedio · Versión: 2