WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / C++

std::condition_variable: auf eine Änderung gemeinsamen Zustands warten

std::condition_variable blockiert einen Thread mit atomarem Freigeben des Mutex und weckt ihn nach einer Benachrichtigung; die Bedingung ist stets erneut zu prüfen.

Version: C++23

Syntax

class condition_variable {
public:
    void notify_one() noexcept;
    void notify_all() noexcept;
    void wait(std::unique_lock<std::mutex>& lock);
    template<class Predicate>
    void wait(std::unique_lock<std::mutex>& lock, Predicate pred);
};

std::condition_variable aus <condition_variable> koordiniert Threads mit std::unique_lock<std::mutex>. wait gibt den Mutex atomar frei und blockiert, dann übernimmt es die Sperre vor der Rückkehr erneut. notify_one weckt einen wartenden Thread, notify_all alle.

Eine Benachrichtigung speichert keinen Zustand und kann verloren gehen, wenn noch niemand wartet. Ändere Zustand wie ready unter demselben Mutex und warte mit wait(lock, pred); dies prüft nach spontanen Aufweckvorgängen erneut. Zur Verringerung von Konkurrenz kann nach dem Entsperren benachrichtigt werden.

Der übergebene unique_lock muss die Sperre besitzen, und alle am selben Objekt wartenden Threads müssen denselben Mutex verwenden; ein Verstoß führt zu undefiniertem Verhalten. Zeitbegrenztes Warten kann nach dem Termin enden. Zerstöre die Bedingungsvariable erst, wenn kein Thread mehr auf ihr blockiert ist; ein aufgeweckter Thread kann noch auf die erneute Übernahme des Mutex warten. Alle Threads wie im Beispiel zu joinen ist ein sicheres Lebensdauermuster, nicht die wörtliche Normanforderung.

Beispiele

#include <condition_variable>
#include <iostream>
#include <mutex>
#include <thread>

int main() {
    std::mutex mutex;
    std::condition_variable ready_changed;
    bool ready = false;
    int value = 0;

    std::jthread worker([&] {
        std::unique_lock lock(mutex);
        ready_changed.wait(lock, [&] { return ready; });
        value *= 2;
    });

    {
        std::lock_guard lock(mutex);
        value = 21;
        ready = true;
    }
    ready_changed.notify_one();
    worker.join();
    std::cout << value << '\n';
}

Ergebnis

42

std::condition_variable → 42

Quellen