std::condition_variable
| Definiert im Header <condition_variable> |
||
| class condition_variable; |
(seit C++11) | |
std::condition_variable ist ein Synchronisationsprimitiv, das zusammen mit einem std::mutex verwendet wird, um einen oder mehrere Threads zu blockieren, bis ein anderer Thread sowohl eine geteilte Variable (die Bedingung) modifiziert als auch die std::condition_variable benachrichtigt.
Der Thread, der die geteilte Variable modifizieren möchte, muss
- Einen std::mutex erwerben (typischerweise über std::lock_guard).
- Die geteilte Variable modifizieren, während der Lock gehalten wird.
notify_oneodernotify_allauf derstd::condition_variableaufrufen (kann nach der Freigabe des Locks erfolgen).
Selbst wenn die geteilte Variable atomar ist, muss sie unter Besitz des Mutex modifiziert werden, um die Modifikation korrekt an den wartenden Thread zu publizieren.
Jeder Thread, der auf eine std::condition_variable warten möchte, muss
- Einen std::unique_lock<std::mutex> auf dem Mutex erwerben, der zum Schutz der geteilten Variable verwendet wird.
- Eine der folgenden Aktionen ausführen
- Die Bedingung prüfen, falls sie bereits aktualisiert und benachrichtigt wurde.
wait,wait_foroderwait_untilauf derstd::condition_variableaufrufen (gibt den Mutex atomar frei und pausiert die Thread-Ausführung, bis die Bedingungsvariable benachrichtigt wird, ein Timeout abläuft oder ein spuriöser Aufruf auftritt; gibt dann den Mutex atomar vor der Rückgabe zurück).- Die Bedingung prüfen und mit dem Warten fortfahren, wenn sie nicht erfüllt ist.
- or
- Die prädikative Überladung von
wait,wait_forundwait_untilverwenden, die dieselben drei Schritte ausführt.
std::condition_variable funktioniert nur mit std::unique_lock<std::mutex>, was auf einigen Plattformen maximale Effizienz ermöglicht. std::condition_variable_any bietet eine Bedingungsvariable, die mit jedem BasicLockable-Objekt funktioniert, wie z. B. std::shared_lock.
Bedingungsvariablen erlauben die gleichzeitige Ausführung der Memberfunktionen wait, wait_for, wait_until, notify_one und notify_all.
Die Klasse std::condition_variable ist ein StandardLayoutType. Sie ist nicht CopyConstructible, MoveConstructible, CopyAssignable oder MoveAssignable.
Inhalt |
[bearbeiten] Geschachtelte Typen
| Name | Definition |
native_handle_type
|
implementierungsdefiniert |
[bearbeiten] Memberfunktionen
| konstruiert das Objekt (public member function) | |
| destruiert das Objekt (public member function) | |
| operator= [gelöscht] |
nicht kopierbar (public member function) |
Benachrichtigung | |
| benachrichtigt einen wartenden Thread (public member function) | |
| benachrichtigt alle wartenden Threads (public member function) | |
Warten | |
| blockiert den aktuellen Thread, bis die Bedingungsvariable geweckt wird (public member function) | |
| blockiert den aktuellen Thread, bis die Bedingungsvariable geweckt wird oder nach Ablauf der angegebenen Timeout-Dauer (public member function) | |
| blockiert den aktuellen Thread, bis die Bedingungsvariable geweckt wird oder bis der angegebene Zeitpunkt erreicht ist (public member function) | |
Native handle | |
| gibt den nativen Handle zurück (public member function) | |
[bearbeiten] Beispiel
std::condition_variable wird in Kombination mit einem std::mutex verwendet, um die Kommunikation zwischen Threads zu erleichtern.
#include <condition_variable> #include <iostream> #include <mutex> #include <string> #include <thread> std::mutex m; std::condition_variable cv; std::string data; bool ready = false; bool processed = false; void worker_thread() { // wait until main() sends data std::unique_lock lk(m); cv.wait(lk, []{ return ready; }); // after the wait, we own the lock std::cout << "Worker thread is processing data\n"; data += " after processing"; // send data back to main() processed = true; std::cout << "Worker thread signals data processing completed\n"; // manual unlocking is done before notifying, to avoid waking up // the waiting thread only to block again (see notify_one for details) lk.unlock(); cv.notify_one(); } int main() { std::thread worker(worker_thread); data = "Example data"; // send data to the worker thread { std::lock_guard lk(m); ready = true; std::cout << "main() signals data ready for processing\n"; } cv.notify_one(); // wait for the worker { std::unique_lock lk(m); cv.wait(lk, []{ return processed; }); } std::cout << "Back in main(), data = " << data << '\n'; worker.join(); }
Ausgabe
main() signals data ready for processing Worker thread is processing data Worker thread signals data processing completed Back in main(), data = Example data after processing
[bearbeiten] Siehe auch
| (C++11) |
bietet eine Bedingungsvariable, die mit jedem Sperrtyp verbunden ist (Klasse) |
| (C++11) |
bietet grundlegende Gegenseitiger-Ausschluss-Funktionen (Klasse) |
| (C++11) |
implementiert einen streng bereichsbezogenen Mutex-Besitz-Wrapper (Klassen-Template) |
| (C++11) |
implementiert verschiebbaren Mutex-Besitz-Wrapper (Klassenvorlage) |
