Baza wiedzyCentrum egzaminacyjne
PLPolski
Wybierz język13

CKTIS / Java

Condition: oczekiwanie i sygnalizowanie w Javie

Czekaj na zmianę stanu w pętli, aktualizuj pozostały budżet w nanosekundach i wybieraj między obudzeniem jednego wątku a obudzeniem wszystkich.

Wersja: Java SE 21

Składnia

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;

Utwórz Condition przez lock.newCondition(). Dla ReentrantLock wszystkie cztery omawiane metody wymagają posiadania powiązanej blokady. Brak blokady skutkuje IllegalMonitorStateException, ale w JDK 21 metody await() i awaitNanos(long) najpierw sprawdzają flagę przerwania. Jeśli jest już ustawiona, zgłaszają InterruptedException zamiast IllegalMonitorStateException. Sprawdzaj i zmieniaj wspólny stan pod tą samą blokadą, a unlock() wywołuj w finally.

Condition.await() czeka bez limitu czasu. Atomowo zwalnia powiązaną blokadę i odzyskuje ją przed powrotem. Czekaj w pętli while, dopóki warunek dotyczący stanu nie jest spełniony: obudzenie może być pozorne albo inny wątek może zmienić stan, zanim odzyskasz blokadę. Obie metody oczekiwania, await() i awaitNanos(long), mogą zgłosić InterruptedException; gdy to robią, flaga przerwania jest czyszczona.

Condition.awaitNanos(long) przyjmuje budżet w nanosekundach i po odzyskaniu blokady zwraca szacowaną pozostałą liczbę nanosekund. W pętli najpierw sprawdź wspólny stan. Jeśli nadal nie spełnia warunku, zakończ oczekiwanie, gdy remaining <= 0L; w przeciwnym razie wykonaj remaining = changed.awaitNanos(remaining). Nie przywracaj początkowego budżetu. Przeciążenie await(long, TimeUnit) zwraca boolean, a nie pozostały budżet.

W przypadku ReentrantLock wywołanie awaitNanos(0L) bez przerwania również całkowicie zwalnia blokadę, odzyskuje ją i przywraca poprzedni licznik przejęć. Nie ma dodatniego budżetu na oczekiwanie, ale odzyskanie blokady może potrwać. Wynik jest niedodatni; nie zakładaj, że wynosi dokładnie zero.

Po zmianie wspólnego stanu Condition.signal() wybiera najwyżej jeden oczekujący wątek, a Condition.signalAll() budzi wszystkie wątki czekające na tym samym obiekcie Condition, także te używające awaitNanos. Żadna metoda nie przekazuje od razu blokady ani nie zachowuje sygnału dla przyszłych oczekujących. Każdy obudzony wątek musi odzyskać blokadę i ponownie sprawdzić stan. Użyj signal(), gdy wystarczy obudzić dowolnego z oczekujących, a signalAll(), gdy kilka wątków może ruszyć dalej lub gdy nie wiadomo, który może to zrobić.

Przykłady

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

Wynik

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

Najpierw program sprawdza tylko znak wyniku i przywrócenie licznika przejęć do 2. Potem każdy wątek roboczy sygnalizuje przybycie przez `arrived.signal()`, a wątek główny otwiera bramkę i wywołuje `gate.signalAll()`. Kolejność wątków nie wpływa na wynik.

Powiązane lekcje

  • Java · Lekcja 30 · Zaawansowany · Wersja: 2
  • Java · Lekcja 54 · Średniozaawansowany · Wersja: 2

Źródła