std::latch
Von cppreference.com
| Definiert in Header <latch> |
||
| class latch; |
(seit C++20) | |
Die Klasse latch ist ein absteigender Zähler vom Typ std::ptrdiff_t, der zur Synchronisation 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 wird. 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 keine Datenrennen ein.
Inhalt |
[bearbeiten] Datenmember
| Name | Definition |
std::ptrdiff_t counter |
der interne Zähler ((exposition-only member object*) |
[bearbeiten] Memberfunktionen
konstruiert einen latch(öffentliche Memberfunktion) | |
zerstört den latch(öffentliche Memberfunktion) | |
| operator= [gelöscht] |
latch ist nicht zuweisbar(öffentliche Memberfunktion) |
| dekrementiert den Zähler nicht-blockierend (öffentliche Memberfunktion) | |
| prüft, ob der interne Zähler null ist (öffentliche Memberfunktion) | |
| blockiert, bis der Zähler null erreicht (öffentliche Memberfunktion) | |
| dekrementiert den Zähler und blockiert, bis er null erreicht (öffentliche Memberfunktion) | |
Konstanten | |
| [static] |
der maximale Wert des Zählers, der von der Implementierung unterstützt wird (öffentliche statische Memberfunktion) |
[bearbeiten] Hinweise
| Feature-Test-Makro | Wert | Std | Feature |
|---|---|---|---|
__cpp_lib_latch |
201907L |
(C++20) | std::latch
|
[bearbeiten] Beispiel
Führen Sie diesen Code aus
#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
[bearbeiten] Siehe auch
| (C++20) |
wiederverwendbare Thread-Barriere (Klassenvorlage) |
