Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / Java

Condition: espera y señalización en Java

Espera un cambio de estado en un bucle, reutiliza el tiempo restante en nanosegundos y elige entre despertar a un hilo o a todos los que esperan.

Versión: Java SE 21

Sintaxis

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;

Crea una Condition con lock.newCondition(). Con ReentrantLock, los cuatro métodos descritos requieren que el hilo que los llama posea el bloqueo asociado. Una llamada sin el bloqueo lanza IllegalMonitorStateException, pero en JDK 21 await() y awaitNanos(long) comprueban primero el estado de interrupción del hilo que los llama. Si el hilo ya está interrumpido, lanzan InterruptedException en su lugar. Comprueba y modifica el estado compartido bajo ese mismo bloqueo y llama a unlock() en finally.

Condition.await() espera sin límite de tiempo. Libera el bloqueo asociado de forma atómica y vuelve a adquirirlo antes de retornar. Espera en un bucle while mientras no se cumpla la condición sobre el estado: el despertar puede ser espurio, o algún otro hilo puede cambiar el estado antes de que recuperes el bloqueo. await() y awaitNanos(long) pueden lanzar InterruptedException; cuando lo hacen, se borra el estado de interrupción.

Condition.awaitNanos(long) recibe un plazo en nanosegundos y devuelve una estimación de los nanosegundos restantes tras recuperar el bloqueo. En el bucle, comprueba primero el estado compartido. Si aún no cumple la condición, deja de esperar cuando remaining <= 0L; de lo contrario, usa remaining = changed.awaitNanos(remaining). No restablezcas el plazo inicial. La sobrecarga await(long, TimeUnit) devuelve un boolean, no el tiempo restante.

Con ReentrantLock, una llamada no interrumpida a awaitNanos(0L) también libera por completo el bloqueo, vuelve a adquirirlo y restaura el recuento original de adquisiciones. No hay un plazo positivo para esperar, pero recuperar el bloqueo puede llevar tiempo. El resultado no es positivo; no supongas que es exactamente cero.

Tras actualizar el estado compartido, Condition.signal() selecciona como máximo a un hilo en espera, mientras que Condition.signalAll() despierta a todos los hilos que esperan en la misma Condition, incluidos los que usan awaitNanos. Ninguno transfiere el bloqueo de inmediato ni guarda la señal para futuros hilos en espera. Cada hilo que despierta debe recuperar el bloqueo y volver a comprobar el estado. Usa signal() si basta con despertar a cualquiera de ellos, y signalAll() si varios pueden continuar o no sabes cuál puede hacerlo.

Ejemplos

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

Resultado

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

La primera prueba solo muestra el resultado de la comparación de signo y el recuento de adquisiciones restaurado a 2. Cada hilo de trabajo anuncia su llegada con `arrived.signal()`, y el hilo principal abre la compuerta y llama a `gate.signalAll()`. El orden de los hilos no afecta a la salida.

Lecciones relacionadas

  • Java · Lección 30 · Avanzado · Versión: 2
  • Java · Lección 54 · Intermedio · Versión: 2

Fuentes