Namensräume
Varianten
Aktionen

std::condition_variable_any::wait_for

Von cppreference.com
 
C++
 
Bibliothek für nebenläufige Programmierung
Threads
(C++11)
(C++20)
(C++17)(C++17)
this_thread Namespace
(C++11)
(C++11)
(C++11)
(C++11)
Kooperatives Beenden
Gegenseitiger Ausschluss
(C++11)
(C++11)
(C++17)
Allgemeines Sperrungsmanagement
(C++11)
(C++11)
(C++17)
(C++11)
(C++14)
(C++11)
(C++11)
(C++11)
(C++11)(C++11)(C++11)(C++11)(C++11)(C++11)
Bedingungsvariablen
(C++11)
(C++11)
(C++11)
(C++11)
Semaphoren
(C++20)(C++20)
Latches und Barriers
(C++20)
(C++20)
Futures
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Sichere Wiederherstellung
(C++26)
(C++26)
(C++26)
Hazard Pointer
(C++26)
(C++26)
(C++26)
Atomare Typen
(C++11)
(C++20)
(C++11)
Initialisierung von atomaren Typen
(C++11)(veraltet in C++20)
(C++11)(veraltet in C++20)
(C++11)
Speicherordnung
(C++11)
(C++11)(deprecated in C++26)
(C++11)
(C++11)
Freie Funktionen für atomare Operationen
(C++11)(C++11)
(C++11)(C++11)
(C++11)(C++11)
(C++11)(C++11)(C++11)(C++11)
(C++11)(C++11)
(C++11)(C++11)
(C++11)(C++11)
(C++11)(C++11)
(C++11)(C++11)
(C++26)(C++26)
(C++26)(C++26)
(C++11)
(C++20)(C++20)
(C++20)
(C++20)
Freie Funktionen für atomare Flags
(C++11)(C++11)
(C++11)(C++11)
(C++20)(C++20)
(C++20)(C++20)
(C++20)
(C++20)
 
std::condition_variable_any
 
template< class Lock, class Rep, class Period >

std::cv_status wait_for( Lock& lock,

                         const std::chrono::duration<Rep, Period>& rel_time );
 (1) (seit C++11)
template< class Lock, class Rep, class Period, class Predicate >

bool wait_for( Lock& lock, const std::chrono::duration<Rep, Period>& rel_time,

               Predicate pred );
 (2) (seit C++11)
template< class Lock, class Rep, class Period, class Predicate >

bool wait_for( Lock& lock, std::stop_token stoken,
               const std::chrono::duration<Rep, Period>& rel_time,

               Predicate pred );
 (3) (seit C++20)

wait_for veranlasst den aufrufenden Thread zu blockieren, bis die Bedingungsvariable benachrichtigt wird, die angegebene Dauer abgelaufen ist oder ein unerwarteter Aufwachvorgang (spurious wakeup) auftritt. pred kann optional angegeben werden, um unerwartete Aufwachvorgänge zu erkennen.

1) Entspricht return wait_until(lock, std::chrono::steady_clock::now() + rel_time);.
2,3) Warten auf eine bestimmte Bedingung, die wahr wird, kann verwendet werden, um sporadische Erweckungen zu ignorieren.
2) Entspricht return wait_until(lock, std::chrono::steady_clock::now() + rel_time, std::move(pred));.
3) Registriert *this für die Dauer dieses Aufrufs, um benachrichtigt zu werden, wenn eine Stornierungsanfrage für den zu stoken gehörenden Stornierungszustand gestellt wird; es entspricht dann return wait_until(lock, std::move(stoken),
                  std::chrono::steady_clock::now() + rel_time, std::move(pred));.

Unmittelbar nach Rückkehr von wait_for ist lock vom aufrufenden Thread gesperrt. Wenn diese Nachbedingung nicht erfüllt werden kann[1], wird std::terminate aufgerufen.

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

Inhalt

[bearbeiten] Parameter

lock - ein Lock, der vom aufrufenden Thread gesperrt sein muss
stoken - ein Stop-Token, um die Unterbrechung dafür zu registrieren
rel_time - Die maximale Wartezeit
pred - das Prädikat, um zu überprüfen, ob das Warten abgeschlossen werden kann
Typanforderungen
-
Lock muss die Anforderungen von BasicLockable erfüllen.
-
Predicate muss die Anforderungen an ein FunctionObject erfüllen.
-
pred() muss ein gültiger Ausdruck sein, und sein Typ und seine Wertkategorie müssen die BooleanTestable-Anforderungen erfüllen.

[bearbeiten] Rückgabewert

1) std::cv_status::timeout, wenn rel_time seit Beginn dieses Aufrufs abgelaufen ist, andernfalls std::cv_status::no_timeout.
2,3) Das letzte Ergebnis von pred() vor der Rückgabe an den Aufrufer.

[bearbeiten] Ausnahmen

1) Zeitlimitbezogene Ausnahmen.
2,3) Zeitüberschreitungsbezogene Ausnahmen und alle Ausnahmen, die von pred ausgelöst werden.

[bearbeiten] Hinweise

Auch wenn unter Sperre benachrichtigt, macht Überladung (1) keine Garantien über den Zustand des zugehörigen Prädikats beim Rückkehren aufgrund von Zeitüberschreitung.

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 Variablen betrachtet werden kann: Die Ordnung ist spezifisch für diese einzelne Bedingungsvariable. Dies macht es unmöglich, dass notify_one() beispielsweise verzögert wird und einen Thread aufweckt, der kurz nach dem Aufruf von notify_one() zu warten begonnen hat.

[bearbeiten] Beispiel

Führen Sie diesen Code aus
#include <chrono>
#include <condition_variable>
#include <iostream>
#include <thread>
 
std::condition_variable_any cv;
std::mutex cv_m; // This mutex is used for three purposes:
                 // 1) to synchronize accesses to i
                 // 2) to synchronize accesses to std::cerr
                 // 3) for the 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();
}

Mögliche Ausgabe

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

[bearbeiten] Fehlerberichte

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

DR angewendet auf Verhalten wie veröffentlicht Korrigiertes Verhalten
LWG 2093 C++11 timeoutbezogene Ausnahmen fehlten in der Spezifikation erwähnt diese Ausnahmen
LWG 2114
(P2167R3)		 C++11 Konvertierbarkeit in bool war zu schwach, um die Erwartungen der Implementierungen widerzuspiegeln Anforderungen verstärkt
LWG 2135 C++11 Das Verhalten war unklar, wenn lock.lock() eine Ausnahme auslöste in diesem Fall wird std::terminate aufgerufen

[bearbeiten] Siehe auch

 blockiert den aktuellen Thread, bis die Bedingungsvariable geweckt wird
(public member function) [bearbeiten]
 blockiert den aktuellen Thread, bis die Bedingungsvariable geweckt wird oder bis der angegebene Zeitpunkt erreicht ist
(public member function) [bearbeiten]
Abgerufen von "https://cppreference.de/mwiki/index.php?title=cpp/thread/condition_variable_any/wait_for&oldid=175959"