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