CKTIS / Java
Condition: espera e sinalização em Java
Espera por uma mudança de estado num ciclo, reutiliza o tempo restante em nanossegundos e escolhe entre acordar uma thread ou todas as que estão à espera.
Versão: Java SE 21
Sintaxe
Java SE 21 — java.util.concurrent.locks.Condition
Condition changed = lock.newCondition();
// Condition method declarations:
void await() throws InterruptedException;
long awaitNanos(long nanosTimeout) throws InterruptedException;
void signal();
void signalAll();
// Distinct timed overload of await:
boolean await(long time, TimeUnit unit) throws InterruptedException;Cria uma Condition com lock.newCondition(). Com ReentrantLock, os quatro métodos aqui descritos exigem que a thread que os invoca detenha o bloqueio associado. Uma chamada sem o bloqueio lança IllegalMonitorStateException, mas no JDK 21 await() e awaitNanos(long) verificam primeiro o estado de interrupção da thread que os invoca. Se a thread já estiver interrompida, lançam InterruptedException em vez de IllegalMonitorStateException. Verifica e altera o estado partilhado sob o mesmo bloqueio e chama unlock() em finally.
Condition.await() espera sem limite de tempo. Liberta atomicamente o bloqueio associado e volta a adquiri-lo antes de retornar. Espera num ciclo while enquanto o estado não satisfizer a condição: pode haver um despertar espúrio, ou outra thread pode alterar o estado antes de recuperares o bloqueio. await() e awaitNanos(long) podem lançar InterruptedException; quando o fazem, limpam o estado de interrupção.
Condition.awaitNanos(long) recebe um orçamento em nanossegundos e devolve uma estimativa dos nanossegundos restantes depois de recuperar o bloqueio. No ciclo, verifica primeiro o estado partilhado. Se a condição continuar por satisfazer, deixa de esperar quando remaining <= 0L; caso contrário, usa remaining = changed.awaitNanos(remaining). Não reponhas o orçamento inicial. A sobrecarga await(long, TimeUnit) devolve um boolean, não o orçamento restante.
Com ReentrantLock, uma chamada não interrompida a awaitNanos(0L) também liberta por completo o bloqueio, volta a adquiri-lo e repõe a contagem original de aquisições. Não há um orçamento positivo para a espera, mas readquirir o bloqueio pode demorar. O resultado não é positivo; não suponhas que é exatamente zero.
Depois de atualizares o estado partilhado, Condition.signal() seleciona no máximo uma thread em espera, enquanto Condition.signalAll() acorda todas as que esperam na mesma Condition, incluindo as que usam awaitNanos. Nenhum destes métodos entrega imediatamente o bloqueio ou guarda um sinal para quem esperar mais tarde. Cada thread acordada tem de readquirir o bloqueio e voltar a verificar o estado. Usa signal() se bastar acordar qualquer uma, e signalAll() se várias puderem avançar ou se não souberes qual pode fazê-lo.
Exemplos
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
public class Main {
private static final ReentrantLock lock = new ReentrantLock();
private static final Condition arrived = lock.newCondition();
private static final Condition gate = lock.newCondition();
private static int ready;
private static int passed;
private static boolean open;
private static void waitAtGate() {
lock.lock();
try {
ready++;
arrived.signal();
while (!open) {
gate.await();
}
passed++;
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
} finally {
lock.unlock();
}
}
public static void main(String[] args) throws InterruptedException {
Thread first = new Thread(Main::waitAtGate);
Thread second = new Thread(Main::waitAtGate);
lock.lock();
try {
lock.lock();
try {
long remaining = gate.awaitNanos(0L);
System.out.println("budget exhausted: " + (remaining <= 0L));
System.out.println("hold count: " + lock.getHoldCount());
} finally {
lock.unlock();
}
first.start();
second.start();
while (ready < 2) {
arrived.await();
}
open = true;
gate.signalAll();
System.out.println("gate opened");
} finally {
lock.unlock();
}
first.join();
second.join();
System.out.println("workers passed: " + passed);
}
}Resultado
budget exhausted: true hold count: 2 gate opened workers passed: 2
O primeiro teste mostra apenas o resultado da comparação de sinal e a contagem de aquisições reposta para 2. Cada thread de trabalho anuncia a chegada com `arrived.signal()`; a thread principal abre a barreira e chama `gate.signalAll()`. A ordem das threads não altera a saída.
Lições relacionadas
- Java · Lição 30 · Avançado · Versão: 2
- Java · Lição 54 · Intermédio · Versão: 2