Namespaces
Variants

std:: latch

From cppreference.net
C++
Concurrency support library
Threads
(C++11)
(C++20)
(C++17) (C++17)
this_thread namespace
(C++11)
(C++11)
Cooperative cancellation
Mutual exclusion
Generic lock management
Condition variables
(C++11)
(C++11)
(C++11)
(C++11)
Semaphores
(C++20) (C++20)
Latches and Barriers
latch
(C++20)
(C++20)
Futures
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Safe reclamation
Hazard pointers
(C++26)
(C++26)
(C++26)
Atomic types
(C++11)
(C++20)
(C++11)
Initialization of atomic types
(C++11) (deprecated in C++20)
(C++11) (deprecated in C++20)
(C++11)
Memory ordering
(C++11)
(C++11) (deprecated in C++26)
(C++11)
(C++11)
Free functions for atomic operations
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11) (C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++26) (C++26)
(C++26) (C++26)
(C++11)
(C++20) (C++20)
(C++20)
(C++20)
Free functions for atomic flags
(C++11) (C++11)
(C++11) (C++11)
(C++20) (C++20)
(C++20) (C++20)
(C++20)
(C++20)
std::latch
Definido en el encabezado <latch>
class latch ;
(desde C++20)

La clase latch es un contador descendente de tipo std::ptrdiff_t que puede utilizarse para sincronizar hilos. El valor del contador se inicializa en la creación. Los hilos pueden bloquearse en el latch hasta que el contador se decrementa a cero. No existe posibilidad de incrementar o reiniciar el contador, lo que convierte al latch en una barrera de un solo uso.

Las invocaciones concurrentes de las funciones miembro de std::latch , excepto el destructor, no introducen carreras de datos.

Contenidos

Miembros de Datos

Nombre Definición
std::ptrdiff_t counter el contador interno
( objeto miembro solo para exposición* )

Funciones miembro

construye un latch
(función miembro pública)
destruye el latch
(función miembro pública)
operator=
[deleted]
latch no es asignable
(función miembro pública)
decrementa el contador de manera no bloqueante
(función miembro pública)
comprueba si el contador interno es igual a cero
(función miembro pública)
bloquea hasta que el contador alcanza cero
(función miembro pública)
decrementa el contador y se bloquea hasta que alcanza cero
(función miembro pública)
Constantes
[static]
el valor máximo del contador soportado por la implementación
(función miembro estática pública)

Notas

Macro de prueba de características Valor Estándar Característica
__cpp_lib_latch 201907L (C++20) std::latch

Ejemplo

Ejecutar este código 
#include <functional>
#include <iostream>
#include <latch>
#include <string>
#include <thread>
struct Job
{
    const std::string name;
    std::string product{"not worked"};
    std::thread action{};
};
int main()
{
    Job jobs[]{{"Annika"}, {"Buru"}, {"Chuck"}};
    std::latch work_done{std::size(jobs)};
    std::latch start_clean_up{1};
    auto work = [&](Job& my_job)
    {
        my_job.product = my_job.name + " worked";
        work_done.count_down();
        start_clean_up.wait();
        my_job.product = my_job.name + " cleaned";
    };
    std::cout << "Work is starting... ";
    for (auto& job : jobs)
        job.action = std::thread{work, std::ref(job)};
    work_done.wait();
    std::cout << "done:\n";
    for (auto const& job : jobs)
        std::cout << "  " << job.product << '\n';
    std::cout << "Workers are cleaning up... ";
    start_clean_up.count_down();
    for (auto& job : jobs)
        job.action.join();
    std::cout << "done:\n";
    for (auto const& job : jobs)
        std::cout << "  " << job.product << '\n';
}

Salida: 

Work is starting... done:
  Annika worked
  Buru worked
  Chuck worked
Workers are cleaning up... done:
  Annika cleaned
  Buru cleaned
  Chuck cleaned

Véase también

(C++20)
barrera de hilos reutilizable
(plantilla de clase)