Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Java

Condition: attesa e segnalazione in Java

Attendi un cambiamento di stato in un ciclo, riutilizza il tempo residuo in nanosecondi e scegli se risvegliare un thread o tutti quelli in attesa.

Versione: Java SE 21

Sintassi

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;

Crea una Condition con lock.newCondition(). Con ReentrantLock, tutti e quattro i metodi descritti richiedono che il thread chiamante detenga il lock associato. Una chiamata senza il lock lancia IllegalMonitorStateException, ma in JDK 21 await() e awaitNanos(long) controllano prima lo stato di interruzione del thread chiamante. Se il thread è già interrotto, lanciano invece InterruptedException. Controlla e modifica lo stato condiviso sotto lo stesso lock e chiama unlock() in finally.

Condition.await() attende senza limiti di tempo. Rilascia atomicamente il lock associato e lo riacquisisce prima di terminare. Attendi in un ciclo while finché lo stato non soddisfa la condizione: può esserci un risveglio spurio, oppure un altro thread può modificare lo stato prima che tu riacquisisca il lock. await() e awaitNanos(long) possono lanciare InterruptedException; in quel caso lo stato di interruzione viene azzerato.

Condition.awaitNanos(long) riceve un budget in nanosecondi e, dopo aver riacquisito il lock, restituisce una stima dei nanosecondi residui. Nel ciclo, controlla prima lo stato condiviso. Se non soddisfa ancora la condizione, smetti di attendere quando remaining <= 0L; altrimenti usa remaining = changed.awaitNanos(remaining). Non ripristinare il budget iniziale. L’overload await(long, TimeUnit) restituisce un boolean, non il budget residuo.

Con ReentrantLock, anche una chiamata non interrotta a awaitNanos(0L) rilascia completamente il lock, lo riacquisisce e ripristina il conteggio di acquisizioni originario. Non c’è un budget di attesa positivo, ma riacquisire il lock può richiedere tempo. Il risultato è non positivo; non dare per scontato che sia esattamente zero.

Dopo aver aggiornato lo stato condiviso, Condition.signal() seleziona al massimo un thread in attesa, mentre Condition.signalAll() risveglia tutti i thread in attesa sulla stessa Condition, anche quelli che usano awaitNanos. Nessuno dei due metodi cede immediatamente il lock o conserva il segnale per chi si metterà in attesa più tardi. Ogni thread risvegliato deve riacquisire il lock e ricontrollare lo stato. Usa signal() se risvegliarne uno qualsiasi è sufficiente e signalAll() se più thread possono proseguire o non sai quale possa farlo.

Esempi

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);
    }
}

Risultato

budget exhausted: true
hold count: 2
gate opened
workers passed: 2

Il primo controllo mostra solo il risultato del test sul segno e il conteggio di acquisizioni ripristinato a 2. Ogni thread di lavoro annuncia poi il proprio arrivo con `arrived.signal()`; il thread principale apre il varco e chiama `gate.signalAll()`. L’ordine dei thread non cambia l’output.

Lezioni correlate

  • Java · Lezione 30 · Avanzato · Versione: 2
  • Java · Lezione 54 · Intermedio · Versione: 2

Fonti