CKTIS / Java
Métodos de ReentrantLock: aquisição, reentrada e condições
Distingue `lock()`, que pode bloquear, das duas sobrecargas de `tryLock()`. Faz corresponder cada aquisição a `unlock()` e usa condições distintas no mesmo bloqueio.
Versão: Java SE 21
Sintaxe
// 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()Em Java SE 21, java.util.concurrent.locks.ReentrantLock é um bloqueio reentrante de exclusão mútua. lock() espera se outra thread detiver o bloqueio; uma interrupção não cancela essa espera. A thread que o detém pode voltar a adquiri-lo sem esperar. getHoldCount() conta as aquisições da thread atual ainda por compensar, e não as threads em espera; 0 não significa que o bloqueio esteja livre.
unlock() reduz o contador em uma unidade e só liberta o bloqueio quando chega a 0. Uma thread que não detenha o bloqueio recebe IllegalMonitorStateException. Entra num bloco try logo após cada aquisição bem-sucedida e coloca o unlock() correspondente em finally. Não libertes o bloqueio por uma tentativa falhada ou que tenha lançado uma exceção. Se o código precisar dos dois bloqueios, adquire-os sempre na mesma ordem, por exemplo gateLock antes de orderLock, e liberta-os pela ordem inversa.
tryLock() não espera: devolve false se outra thread detiver o bloqueio e true se o adquirir, incluindo por reentrada. Pode passar à frente das threads em fila mesmo num bloqueio equitativo. tryLock(timeout, unit) respeita a política de equidade quando está ativa, espera no máximo o tempo indicado (timeout <= 0 significa que não espera) e devolve false se não adquirir o bloqueio nesse prazo. Uma interrupção à entrada ou durante a aquisição provoca InterruptedException e limpa o estado de interrupção; unit == null é inválido e provoca NullPointerException.
Cada chamada a newCondition() cria um objeto Condition distinto associado ao mesmo bloqueio. Num buffer de um só elemento, notEmpty destina-se aos consumidores e notFull aos produtores. Chamar signal() sem deter esse bloqueio provoca IllegalMonitorStateException. await() verifica primeiro o estado de interrupção da thread atual. Se a thread já estiver interrompida, await() limpa esse estado e lança InterruptedException antes de verificar se a thread detém o bloqueio e sem o libertar. Caso contrário, await() lança IllegalMonitorStateException se a thread não detiver o bloqueio. Se passar à espera, await() liberta o bloqueio de forma atómica e volta a adquiri-lo com o contador original antes de a chamada terminar. Verifica o estado num ciclo while, porque a espera pode terminar sem sinalização. Sinaliza depois de alterar o estado, mantendo o bloqueio; signal() não o liberta.
Exemplos
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
Duas chamadas a `lock()` dão o primeiro `2` depois do `0` inicial. Um `unlock()` deixa `1`, e o `tryLock()` imediato da thread que detém o bloqueio repõe o `2`. As duas libertações restantes dão `1` e `0`. As duas tentativas com limite de tempo usam o mesmo `orderLock` e têm sucesso sem contenção. `put(42)` e `take()` usam condições distintas no único bloqueio do buffer; nenhuma operação espera nesta execução.
Lições relacionadas
- Java · Lição 30 · Avançado · Versão: 2
- Java · Lição 54 · Intermédio · Versão: 2
- Java · Lição 58 · Intermédio · Versão: 2