Znalostná bázaCentrum skúšok
SKSlovenčina
Vybrať jazyk13

CKTIS / Java

Condition: čakanie a signalizácia v Jave

Čakaj na zmenu stavu v cykle, prenášaj zostávajúci čas v nanosekundách a rozhodni sa, či zobudiť jedno, alebo všetky čakajúce vlákna.

Verzia: Java SE 21

Syntax

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;

Vytvor Condition cez lock.newCondition(). Pri ReentrantLock musí volajúce vlákno pri všetkých štyroch opísaných metódach držať príslušný zámok. Volanie bez zámku vyvolá IllegalMonitorStateException, ale v JDK 21 metódy await() a awaitNanos(long) najprv skontrolujú príznak prerušenia volajúceho vlákna. Ak je už nastavený, vyhodia namiesto toho InterruptedException. Zdieľaný stav kontroluj a meň pod tým istým zámkom a unlock() volaj v finally.

Condition.await() čaká bez časového limitu. Atómovo uvoľní príslušný zámok a pred návratom ho znova získa. Čakaj v cykle while, kým stav nespĺňa požadovanú podmienku: vlákno sa môže zobudiť bez signálu alebo iné vlákno môže zmeniť stav skôr, než zámok znova získaš. await() a awaitNanos(long) môžu vyhodiť InterruptedException; vtedy sa príznak prerušenia vymaže.

Condition.awaitNanos(long) prijíma časový rozpočet v nanosekundách a po opätovnom získaní zámku vracia odhad zostávajúcich nanosekúnd. V cykle najprv skontroluj zdieľaný stav. Ak podmienka stále nie je splnená, prestaň čakať pri remaining <= 0L; inak použi remaining = changed.awaitNanos(remaining). Neobnovuj pôvodný rozpočet. Preťažená verzia await(long, TimeUnit) vracia boolean, nie zostávajúci čas.

Pri ReentrantLock aj neprerušené volanie awaitNanos(0L) zámok úplne uvoľní, znova ho získa a obnoví pôvodný počet jeho získaní vláknom. Na čakanie nie je k dispozícii kladný rozpočet, ale opätovné získanie zámku môže trvať. Výsledok je nekladný; nepredpokladaj, že je presne nula.

Po zmene zdieľaného stavu Condition.signal() vyberie najviac jedno čakajúce vlákno, kým Condition.signalAll() zobudí všetky vlákna čakajúce na tej istej Condition vrátane tých, ktoré používajú awaitNanos. Ani jedna metóda neodovzdá zámok ihneď ani neuchová signál pre budúcich čakajúcich. Každé zobudené vlákno musí zámok znova získať a opäť skontrolovať stav. Použi signal(), ak stačí zobudiť ľubovoľné čakajúce vlákno, a signalAll(), ak môže pokračovať viacero vlákien alebo nevieš, ktoré môže pokračovať.

Prí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ýsledok

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

Prvý test vypíše len výsledok kontroly znamienka a obnovený počet získaní zámku 2. Každé pracovné vlákno potom ohlási príchod cez `arrived.signal()` a hlavné vlákno otvorí bránu a zavolá `gate.signalAll()`. Poradie vlákien nemení výstup.

Súvisiace lekcie

  • Java · Lekcia 30 · Pokročilá · Verzia: 2
  • Java · Lekcia 54 · Stredne pokročilá · Verzia: 2

Zdroje