CKTIS / Java
Condition — attendre un état protégé par un verrou
Condition permet à un thread d’attendre un changement d’un état partagé protégé par un Lock. Découvrez await, awaitNanos, signal et signalAll, ainsi que l’importance de vérifier l’état dans une boucle.
Version : Java SE 21; repository runtime, production runtime not attested
Syntaxe
Condition changed = lock.newCondition();
changed.await();
long remaining = changed.awaitNanos(nanosTimeout);
changed.signal();
changed.signalAll();Condition représente une file d’attente associée à un Lock, et non une valeur booléenne. Créez-la avec lock.newCondition(). Un même verrou peut avoir plusieurs files de ce type, par exemple pour un tampon vide et un tampon plein.
Condition.await libère le verrou de façon atomique pendant l’attente et le reprend avant de retourner. Vérifiez l’état dans une boucle while, car des réveils intempestifs sont possibles. Condition.awaitNanos accepte des nanosecondes et renvoie une estimation du temps restant. Transmettez cette valeur à l’attente suivante au lieu de redémarrer le délai. Un résultat <= 0 signifie qu’il ne reste plus de temps. Les deux méthodes peuvent lever InterruptedException et effacer le statut d’interruption. Propagez l’exception ou rétablissez le statut si vous l’interceptez.
Condition.signal réveille un thread en attente, tandis que Condition.signalAll les réveille tous. La signalisation ne transfère pas le verrou : le thread réveillé doit le reprendre. Avec ReentrantLock, le thread appelant doit détenir le verrou lorsqu’il appelle une méthode d’attente ou de signalisation. Appeler signal() ou signalAll() sans détenir le verrou lève IllegalMonitorStateException. Dans l’implémentation de ReentrantLock du JDK 21, await() et awaitNanos() vérifient le statut d’interruption avant de vérifier que le thread détient le verrou. Si le statut d’interruption est déjà positionné à l’entrée de la méthode, celle-ci lève InterruptedException, même si le thread ne détient pas le verrou. Si le statut n’est pas positionné, un appel sans détenir le verrou lève IllegalMonitorStateException. Libérez toujours le verrou dans finally.
Vérifiez et modifiez l’état protégé sous le même verrou. L’exemple affiche ready, que publish s’exécute ou non avant le début de l’attente : c’est l’état ready qui est conservé, pas le signal. Cette fiche porte sur Java SE 21 ; ni le dépôt ni l’environnement d’exécution de production n’ont été attestés.
Exemples
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");
}
}Résultat
ready
Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.