Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

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

Fontes