Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / Java

Condition : attendre et signaler en Java

Attendez un changement d’état dans une boucle, réutilisez le temps restant en nanosecondes et choisissez de réveiller un seul thread ou tous ceux qui attendent.

Version : Java SE 21

Syntaxe

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;

Créez une Condition avec lock.newCondition(). Avec ReentrantLock, les quatre méthodes présentées exigent que le thread appelant détienne le verrou associé. Un appel sans ce verrou lève IllegalMonitorStateException, mais dans le JDK 21, await() et awaitNanos(long) vérifient d’abord le statut d’interruption du thread appelant. Si ce statut est déjà activé, elles lèvent InterruptedException à la place. Vérifiez et modifiez l’état partagé sous ce même verrou, puis appelez unlock() dans finally.

Condition.await() attend sans limite de temps. La méthode libère atomiquement le verrou associé et le reprend avant de se terminer. Attendez dans une boucle while tant que l’état voulu n’est pas atteint : un réveil peut être intempestif, ou un autre thread peut modifier l’état avant que vous repreniez le verrou. await() et awaitNanos(long) peuvent lever InterruptedException ; dans ce cas, le statut d’interruption est effacé.

Condition.awaitNanos(long) reçoit un budget en nanosecondes et renvoie, après avoir repris le verrou, une estimation du nombre de nanosecondes restantes. Dans la boucle, vérifiez d’abord l’état partagé. S’il ne satisfait toujours pas la condition, cessez d’attendre si remaining <= 0L ; sinon, utilisez remaining = changed.awaitNanos(remaining). Ne réinitialisez pas le budget. La surcharge await(long, TimeUnit) renvoie un boolean, pas le temps restant.

Avec ReentrantLock, un appel non interrompu à awaitNanos(0L) libère quand même entièrement le verrou, le reprend et rétablit le nombre initial d’acquisitions. Le budget d’attente n’est pas positif, mais reprendre le verrou peut prendre du temps. Le résultat est négatif ou nul ; ne supposez pas qu’il vaut exactement zéro.

Après la mise à jour de l’état partagé, Condition.signal() sélectionne au plus un thread en attente, tandis que Condition.signalAll() réveille tous ceux qui attendent sur la même Condition, y compris avec awaitNanos. Aucune de ces méthodes ne cède immédiatement le verrou ni ne conserve un signal pour les futurs threads en attente. Chaque thread réveillé doit reprendre le verrou et vérifier de nouveau l’état. Utilisez signal() si réveiller n’importe lequel suffit, et signalAll() si plusieurs peuvent poursuivre ou si vous ignorez lequel le peut.

Exemples

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

Résultat

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

Le premier test affiche seulement le résultat de la comparaison de signe et le compteur d’acquisitions rétabli à 2. Chaque thread de travail annonce ensuite son arrivée avec `arrived.signal()`, puis le thread principal ouvre la barrière et appelle `gate.signalAll()`. L’ordre des threads ne change pas la sortie.

Leçons associées

  • Java · Leçon 30 · Avancé · Version : 2
  • Java · Leçon 54 · Intermédiaire · Version : 2

Sources