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

CKTIS / C++

std::latch — esperar una sola vez a que un contador llegue a cero

std::latch de <latch> permite que los hilos esperen a que un contador llegue a cero. count_down() indica que se ha completado una unidad de trabajo, mientras que wait() espera a que termine la cuenta atrás sin modificar el contador.

Versión: C++23; repository compiler flag, production runtime not attested

Sintaxis

#include <latch>
std::latch done{expected};
done.count_down();
done.wait();

std::latch es un mecanismo de sincronización de un solo uso de <latch>. Su constructor establece el contador en expected, que debe cumplir 0 <= expected && expected <= std::latch::max(). El contador representa las notificaciones pendientes, que no tienen por qué corresponder a hilos distintos. Una vez que el contador llega a cero, el objeto no se puede reiniciar ni reutilizar para otra ronda.

std::latch::count_down(update) resta update de forma atómica; su valor predeterminado es 1. Se requiere 0 <= update, y update no debe superar el valor actual del contador; por tanto, no llames a count_down() con el valor predeterminado cuando el contador ya sea cero. Este método no espera a las demás notificaciones. std::latch::wait() no decrementa el contador: se bloquea hasta que llegue a cero, o retorna inmediatamente si ya está en cero. Si faltan notificaciones, la espera puede prolongarse indefinidamente.

En C++23, count_down() precede, en el sentido de la relación strongly happens-before, al retorno de las llamadas que se desbloquean en ese latch. Esta garantía no cubre explícitamente una llamada a wait() que comienza después de que el contador haya llegado a cero. En el ejemplo, worker puede llamar a count_down() antes de que el hilo principal llame a wait(), por lo que wait() por sí sola no garantiza que la lectura no atómica de result sea segura con cualquier planificación de los hilos. El latch tampoco protege frente a escrituras concurrentes arbitrarias en datos compartidos.

El objeto debe permanecer vivo mientras se realizan operaciones sobre él. En el ejemplo, worker se destruye antes que done, pero el hilo principal no depende del destructor de std::jthread: llama explícitamente a worker.join() después de wait() y antes de leer result. La finalización del hilo de trabajo se sincroniza con el retorno satisfactorio de worker.join(), de modo que la lectura de result es segura con independencia de que wait() haya bloqueado o no. Si la ejecución termina correctamente, el programa imprime 42 seguido de un salto de línea.

Ejemplos

#include <iostream>
#include <latch>
#include <thread>

int main() {
    int result = 0;
    std::latch done{1};

    std::jthread worker([&] {
        result = 42;
        done.count_down();
    });

    done.wait();
    worker.join();
    std::cout << result << '\n';
}

Resultado

42

El código mostrado y el resultado declarado se verificaron en un entorno aislado mediante el método registrado en la evidencia de verificación de esta versión exacta.

Fuentes