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
Défini dans l'en-tête <latch>
class latch ;
(depuis C++20)

La classe latch est un compteur descendant de type std::ptrdiff_t qui peut être utilisé pour synchroniser des threads. La valeur du compteur est initialisée lors de la création. Les threads peuvent se bloquer sur le latch jusqu'à ce que le compteur soit décrémenté à zéro. Il n'est pas possible d'augmenter ou de réinitialiser le compteur, ce qui fait du latch une barrière à usage unique.

Les invocations concurrentes des fonctions membres de std::latch , à l'exception du destructeur, n'introduisent pas de courses de données.

Table des matières

Membres de Données

Nom Définition
std::ptrdiff_t counter le compteur interne
( objet membre d'exposition uniquement* )

Fonctions membres

construit un latch
(fonction membre publique)
détruit le latch
(fonction membre publique)
operator=
[deleted]
latch n'est pas assignable
(fonction membre publique)
décrémente le compteur de manière non bloquante
(fonction membre publique)
teste si le compteur interne est égal à zéro
(fonction membre publique)
bloque jusqu'à ce que le compteur atteigne zéro
(fonction membre publique)
décrémente le compteur et bloque jusqu'à ce qu'il atteigne zéro
(fonction membre publique)
Constantes
[static]
la valeur maximale du compteur supportée par l'implémentation
(fonction membre statique publique)

Notes

Macro de test de fonctionnalité Valeur Std Fonctionnalité
__cpp_lib_latch 201907L (C++20) std::latch

Exemple

Exécuter ce code 
#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';
}

Sortie : 

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

Voir aussi

(C++20)
barrière de threads réutilisable
(modèle de classe)