Znalostní bázeCentrum zkoušek
CSČeština
Vybrat jazyk13

CKTIS / Java

Condition: čekání a signalizace v Javě

Čekej na změnu stavu ve smyčce, předávej zbývající čas v nanosekundách a rozhodni se, zda probudit jedno, nebo všechna čekající vlákna.

Verze: 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;

Vytvoř Condition pomocí lock.newCondition(). U ReentrantLock musí volající vlákno při použití všech čtyř popsaných metod držet přidružený zámek. Volání bez zámku vyvolá IllegalMonitorStateException, ale v JDK 21 metody await() a awaitNanos(long) nejprve zkontrolují příznak přerušení volajícího vlákna. Pokud je už nastavený, vyhodí místo toho InterruptedException. Sdílený stav kontroluj a měň pod stejným zámkem a unlock() volej v finally.

Condition.await() čeká bez časového limitu. Atomicky uvolní přidružený zámek a před návratem jej znovu získá. Čekej ve smyčce while, dokud stav nesplňuje požadovanou podmínku: vlákno se může probudit bez signálu nebo jiné vlákno může stav změnit dříve, než zámek znovu získáš. await() a awaitNanos(long) mohou vyhodit InterruptedException; v takovém případě se příznak přerušení vymaže.

Condition.awaitNanos(long) přijímá časový rozpočet v nanosekundách a po opětovném získání zámku vrací odhad zbývajících nanosekund. Ve smyčce nejprve zkontroluj sdílený stav. Pokud podmínka stále neplatí, přestaň čekat při remaining <= 0L; jinak použij remaining = changed.awaitNanos(remaining). Neobnovuj původní rozpočet. Přetížená varianta await(long, TimeUnit) vrací boolean, nikoli zbývající čas.

U ReentrantLock také nepřerušené volání awaitNanos(0L) zámek zcela uvolní, znovu jej získá a obnoví původní počet jeho získání vláknem. Na čekání není kladný rozpočet, ale opětovné získání zámku může trvat. Výsledek je nekladný; nemusí být přesně nula.

Po změně sdíleného stavu Condition.signal() vybere nejvýše jedno čekající vlákno, zatímco Condition.signalAll() probudí všechna vlákna čekající na téže Condition, včetně těch, která používají awaitNanos. Ani jedna metoda nepředá zámek okamžitě ani neuchová signál pro budoucí čekající. Každé probuzené vlákno musí zámek znovu získat a stav znovu otestovat. Použij signal(), když stačí probudit libovolné čekající vlákno, a signalAll(), když může pokračovat více vláken nebo nevíš, které může pokračovat.

Příklady

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

Výsledek

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

První test vypíše jen výsledek kontroly znaménka a obnovený počet získání zámku 2. Každé pracovní vlákno pak ohlásí příchod pomocí `arrived.signal()` a hlavní vlákno otevře bránu a zavolá `gate.signalAll()`. Pořadí vláken výstup nemění.

Související lekce

  • Java · Lekce 30 · Pokročilá · Verze: 2
  • Java · Lekce 54 · Středně pokročilá · Verze: 2

Zdroje