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
Definiert im Header <latch>
class latch ;
(seit C++20)

Die latch -Klasse ist ein Abwärtszähler vom Typ std::ptrdiff_t , der zur Synchronisierung von Threads verwendet werden kann. Der Wert des Zählers wird bei der Erstellung initialisiert. Threads können auf dem Latch blockieren, bis der Zähler auf Null dekrementiert wurde. Es gibt keine Möglichkeit, den Zähler zu erhöhen oder zurückzusetzen, was den Latch zu einer Einweg-Barriere macht.

Gleichzeitige Aufrufe der Memberfunktionen von std::latch , mit Ausnahme des Destruktors, führen nicht zu Datenrennen.

Inhaltsverzeichnis

Datenmitglieder

Name Definition
std::ptrdiff_t counter der interne Zähler
( Nur zur Veranschaulichung verwendetes Mitgliedsobjekt* )

Memberfunktionen

konstruiert einen latch
(öffentliche Elementfunktion)
zerstört den latch
(öffentliche Elementfunktion)
operator=
[deleted]
latch ist nicht zuweisbar
(öffentliche Elementfunktion)
dekrementiert den Zähler auf nicht-blockierende Weise
(öffentliche Elementfunktion)
prüft ob der interne Zähler gleich null ist
(öffentliche Elementfunktion)
blockiert bis der Zähler null erreicht
(öffentliche Elementfunktion)
dekrementiert den Zähler und blockiert bis er null erreicht
(öffentliche Elementfunktion)
Konstanten
[static]
der maximale vom Implementation unterstützte Zählerwert
(öffentliche statische Elementfunktion)

Hinweise

Feature-Test Makro Wert Std Feature
__cpp_lib_latch 201907L (C++20) std::latch

Beispiel

Diesen Code ausführen 
#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';
}

Ausgabe: 

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

Siehe auch

(C++20)
wiederverwendbare Thread-Barriere
(Klassentemplate)