std::condition_variable:: notify_all

Entsperrt alle Threads, die derzeit auf * this warten.

Hinweise

Die Effekte von notify_one() / notify_all() und jeder der drei atomaren Teile von wait() / wait_for() / wait_until() (Entsperren+Warten, Aufwecken und Sperren) finden in einer einzigen Gesamtordnung statt, die als Modifikationsordnung einer atomaren Variable betrachtet werden kann: Die Ordnung ist spezifisch für diese individuelle Bedingungsvariable. Dies macht es unmöglich, dass notify_one() beispielsweise verzögert wird und einen Thread entsperrt, der gerade nach dem Aufruf von notify_one() mit dem Warten begonnen hat.

Der benachrichtigende Thread muss die Sperre nicht auf demselben Mutex halten wie der/die wartenden Thread(s). Dies könnte eine Verschlechterung der Performance darstellen, da der benachrichtigte Thread sofort wieder blockieren würde, während er auf die Freigabe der Sperre durch den benachrichtigenden Thread wartet, obwohl einige Implementierungen dieses Muster erkennen und nicht versuchen, den Thread zu wecken, der unter Sperre benachrichtigt wird.

Beispiel

#include <chrono>
#include <condition_variable>
#include <iostream>
#include <thread>
std::condition_variable cv;
std::mutex cv_m; // Dieses Mutex wird für drei Zwecke verwendet:
                 // 1) zum Synchronisieren von Zugriffen auf i
                 // 2) zum Synchronisieren von Zugriffen auf std::cerr
                 // 3) für die Condition Variable cv
int i = 0;
void waits()
{
    std::unique_lock<std::mutex> lk(cv_m);
    std::cerr << "Waiting... \n";
    cv.wait(lk, []{ return i == 1; });
    std::cerr << "...finished waiting. i == 1\n";
}
void signals()
{
    std::this_thread::sleep_for(std::chrono::seconds(1));
    {
        std::lock_guard<std::mutex> lk(cv_m);
        std::cerr << "Notifying...\n";
    }
    cv.notify_all();
    std::this_thread::sleep_for(std::chrono::seconds(1));
    {
        std::lock_guard<std::mutex> lk(cv_m);
        i = 1;
        std::cerr << "Notifying again...\n";
    }
    cv.notify_all();
}
int main()
{
    std::thread t1(waits), t2(waits), t3(waits), t4(signals);
    t1.join(); 
    t2.join(); 
    t3.join();
    t4.join();
}

Waiting...
Waiting...
Waiting...
Notifying...
Notifying again...
...finished waiting. i == 1
...finished waiting. i == 1
...finished waiting. i == 1

Siehe auch