База знанияИзпитен център
BGБългарски
Избери език13

CKTIS / Java

Condition: изчакване и сигнализиране в Java

Изчаквай промяна на състоянието в цикъл, използвай оставащото време в наносекунди и избирай дали да събудиш една или всички чакащи нишки.

Версия: Java SE 21

Синтаксис

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;

Създай Condition чрез lock.newCondition(). При ReentrantLock извикващата нишка трябва да държи свързаното заключване и за четирите разглеждани метода. Извикване без заключването води до IllegalMonitorStateException, но в JDK 21 await() и awaitNanos(long) първо проверяват флага за прекъсване на извикващата нишка. Ако той вече е зададен, вместо това хвърлят InterruptedException. Проверявай и променяй споделеното състояние под същото заключване, а unlock() извиквай във finally.

Condition.await() изчаква без ограничение във времето. Методът освобождава атомарно свързаното заключване и го придобива отново, преди да се върне. Изчаквай в цикъл while, докато състоянието не изпълни условието: нишката може да се събуди без сигнал или друга нишка може да промени състоянието, преди да придобиеш заключването отново. await() и awaitNanos(long) могат да хвърлят InterruptedException; тогава флагът за прекъсване се изчиства.

Condition.awaitNanos(long) приема времеви бюджет в наносекунди и след повторното придобиване на заключването връща оценка на оставащите наносекунди. В цикъла първо проверявай споделеното състояние. Ако условието още не е изпълнено, спри да чакаш при remaining <= 0L; в противен случай използвай remaining = changed.awaitNanos(remaining). Не връщай бюджета към началната му стойност. Претовареният вариант await(long, TimeUnit) връща boolean, а не оставащо време.

При ReentrantLock и непрекъснато извикване на awaitNanos(0L) заключването все пак се освобождава напълно и се придобива отново, а първоначалният брой придобивания се възстановява. Няма положителен бюджет за изчакване, но повторното придобиване може да отнеме време. Резултатът не е положителен; не приемай, че е точно нула.

След промяна на споделеното състояние Condition.signal() избира най-много една чакаща нишка, а Condition.signalAll() събужда всички, които чакат на същия обект Condition, включително чрез awaitNanos. Нито един от двата метода не предава заключването веднага и не пази сигнал за бъдещи чакащи нишки. Всяка събудена нишка трябва да придобие заключването и да провери състоянието отново. Използвай signal(), ако е достатъчно да събудиш която и да е чакаща нишка, и signalAll(), ако няколко могат да продължат или не знаеш коя може да продължи.

Примери

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

Резултат

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

Първата проверка извежда само резултата от проверката на знака и възстановения брой придобивания на заключването — 2. Всяка работна нишка обявява пристигането си чрез `arrived.signal()`, а главната отваря прохода и извиква `gate.signalAll()`. Редът на нишките не променя изхода.

Свързани уроци

  • Java · Урок 30 · Напреднало · Версия: 2
  • Java · Урок 54 · Средно · Версия: 2

Източници