std::condition_variable_any:: wait_for

wait_for bewirkt, dass der aktuelle Thread blockiert, bis die Bedingungsvariable benachrichtigt wird, die angegebene Dauer abgelaufen ist oder ein spontanes Aufwachen auftritt. pred kann optional bereitgestellt werden, um spontanes Aufwachen zu erkennen.

Unmittelbar nachdem wait_for zurückkehrt, ist lock durch den aufrufenden Thread gesperrt. Wenn diese Nachbedingung nicht erfüllt werden kann ^[1] , ruft es std::terminate auf.

1. ↑ Dies kann passieren, wenn das erneute Sperren des Mutex eine Exception auslöst.

Parameter

Rückgabewert

Ausnahmen

Hinweise

Selbst wenn unter Sperre benachrichtigt, gibt Overload (1) keine Garantien über den Zustand des assoziierten Prädikats bei Rückkehr aufgrund von Timeout.

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 Modifikationsreihenfolge einer atomaren Variable betrachtet werden kann: Die Reihenfolge 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.

Beispiel

#include <chrono>
#include <condition_variable>
#include <iostream>
#include <thread>
std::condition_variable_any 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

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

Siehe auch