std:: barrier

Le modèle de classe std::barrier fournit un mécanisme de coordination de threads qui bloque un groupe de threads de taille connue jusqu'à ce que tous les threads de ce groupe aient atteint la barrière. Contrairement au std::latch , les barrières sont réutilisables : une fois qu'un groupe de threads arrivants est débloqué, la barrière peut être réutilisée. Contrairement au std::latch , les barrières exécutent un appelable potentiellement vide avant de débloquer les threads.

La durée de vie d'un objet barrière consiste en une ou plusieurs phases. Chaque phase définit un point de synchronisation de phase où les threads en attente se bloquent. Les threads peuvent arriver à la barrière, mais différer l'attente sur le point de synchronisation de phase en appelant arrive . Ces threads peuvent ensuite se bloquer sur le point de synchronisation de phase en appelant wait .

Une barrière phase se compose des étapes suivantes :

1. Le compteur attendu est décrémenté par chaque appel à arrive ou arrive_and_drop .
2. Lorsque le compteur attendu atteint zéro, l' étape de finalisation de phase est exécutée, ce qui signifie que la completion est invoquée et tous les threads bloqués sur le point de synchronisation de phase sont débloqués. La fin de l'étape de finalisation se produit fortement avant que tous les appels débloqués par l'étape de finalisation ne retournent.
   Exactement une fois après que le compteur attendu atteint zéro, un thread exécute l'étape de finalisation lors de son appel à arrive , arrive_and_drop , ou wait , sauf qu'il est défini par l'implémentation si l'étape s'exécute lorsqu'aucun thread n'appelle wait .
3. Lorsque l'étape de finalisation se termine, le compteur attendu est réinitialisé à la valeur spécifiée lors de la construction moins le nombre d'appels à arrive_and_drop depuis, et la prochaine phase de barrière commence.

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

Paramètres du modèle

L'argument de modèle par défaut de CompletionFunction est un type de fonction objet non spécifié qui satisfait en outre aux exigences de DefaultConstructible . L'appel d'une lvalue de celui-ci sans arguments n'a aucun effet.

Types membres

Membres de données

Fonctions membres

Notes

Exemple

#include <barrier>
#include <iostream>
#include <string>
#include <syncstream>
#include <thread>
#include <vector>
int main()
{
    const auto workers = {"Anil", "Busara", "Carl"};
    auto on_completion = []() noexcept
    {
        // locking not needed here
        static auto phase =
            "... done\n"
            "Cleaning up...\n";
        std::cout << phase;
        phase = "... done\n";
    };
    std::barrier sync_point(std::ssize(workers), on_completion);
    auto work = [&](std::string name)
    {
        std::string product = "  " + name + " worked\n";
        std::osyncstream(std::cout) << product;  // ok, op<< call is atomic
        sync_point.arrive_and_wait();
        product = "  " + name + " cleaned\n";
        std::osyncstream(std::cout) << product;
        sync_point.arrive_and_wait();
    };
    std::cout << "Starting...\n";
    std::vector<std::jthread> threads;
    threads.reserve(std::size(workers));
    for (auto const& worker : workers)
        threads.emplace_back(work, worker);
}

Starting...
  Anil worked
  Carl worked
  Busara worked
... done
Cleaning up...
  Busara cleaned
  Carl cleaned
  Anil cleaned
... done

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

Voir aussi