CKTIS / Java
Condition — attendere uno stato protetto da un lock
Condition consente a un thread di attendere una modifica dello stato condiviso protetto da un Lock. Scopri await, awaitNanos, signal e signalAll e perché il controllo dello stato va eseguito in un ciclo.
Versione: Java SE 21; repository runtime, production runtime not attested
Sintassi
Condition changed = lock.newCondition();
changed.await();
long remaining = changed.awaitNanos(nanosTimeout);
changed.signal();
changed.signalAll();Condition rappresenta una coda di attesa associata a un Lock, non un valore booleano. Creala con lock.newCondition(). Un lock può avere più code di questo tipo, per esempio una per un buffer vuoto e una per uno pieno.
Condition.await rilascia il lock in modo atomico durante l’attesa e lo acquisisce di nuovo prima di restituire il controllo. Controlla lo stato in un ciclo while, perché sono possibili risvegli spurii. Condition.awaitNanos accetta nanosecondi e restituisce una stima del tempo rimanente. Passa questo valore all’attesa successiva invece di riavviare il timeout. Un risultato <= 0 indica che il tempo è scaduto. Entrambi i metodi possono generare InterruptedException e azzerare lo stato di interruzione. Propaga l’eccezione oppure ripristina lo stato se la intercetti.
Condition.signal risveglia un thread in attesa, mentre Condition.signalAll li risveglia tutti. La segnalazione non trasferisce il lock: il thread risvegliato deve acquisirlo di nuovo. Con ReentrantLock, il thread deve possedere il lock quando chiama un metodo di attesa o di segnalazione. Chiamare signal() o signalAll() senza possedere il lock genera IllegalMonitorStateException. Nell’implementazione di ReentrantLock di JDK 21, await() e awaitNanos() controllano lo stato di interruzione prima di verificare se il thread possiede il lock. Se lo stato di interruzione è già impostato all’ingresso nel metodo, viene generata InterruptedException anche se il thread non possiede il lock. Se lo stato non è impostato, una chiamata senza possedere il lock genera IllegalMonitorStateException. Rilascia sempre il lock in finally.
Controlla e modifica lo stato protetto usando lo stesso lock. L’esempio stampa ready sia che publish venga eseguito prima dell’inizio dell’attesa, sia che venga eseguito dopo: viene mantenuto lo stato ready, non il segnale. Questa scheda riguarda Java SE 21; non sono stati attestati né il repository né l’ambiente di produzione.
Esempi
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
public class ConditionDemo {
private final ReentrantLock lock = new ReentrantLock();
private final Condition changed = lock.newCondition();
private boolean ready;
void awaitReady() throws InterruptedException {
lock.lock();
try {
while (!ready) {
changed.await();
}
} finally {
lock.unlock();
}
}
void publish() {
lock.lock();
try {
ready = true;
changed.signalAll();
} finally {
lock.unlock();
}
}
public static void main(String[] args) throws InterruptedException {
ConditionDemo demo = new ConditionDemo();
Thread producer = new Thread(demo::publish);
producer.start();
demo.awaitReady();
producer.join();
System.out.println("ready");
}
}Risultato
ready
Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.