std::condition_variable_any::wait_until
| template< class Lock, class Clock, class Duration > std::cv_status |
(1) | (seit C++11) |
| template< class Lock, class Clock, class Duration, class Predicate > bool wait_until( Lock& lock, |
(2) | (seit C++11) |
| template< class Lock, class Clock, class Duration, class Predicate > bool wait_until( Lock& lock, std::stop_token stoken, |
(3) | (seit C++20) |
wait_until bewirkt, dass der aktuelle Thread blockiert wird, bis die Bedingungsvariable benachrichtigt wird, die angegebene Zeitspanne abgelaufen ist oder ein Scheinkorrektur tritt. pred kann optional bereitgestellt werden, um Scheinkorrekturen zu erkennen.
if (wait_until(lock, abs_time) == std::cv_status::timeout)
return pred();
return true;.
{
if (pred())
return true;
if (wait_until(lock, abs_time) == std::cv_status::timeout)
return pred();
}
return pred();.
Unmittelbar nach der Rückkehr von wait_until ist lock vom aufrufenden Thread gesperrt. Wenn diese Nachbedingung nicht erfüllt werden kann[1], wird std::terminate aufgerufen.
- ↑ 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 |
| abs_time | - | Der Zeitpunkt, zu dem das Warten abläuft |
| 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
[bearbeiten] Ausnahmen
[bearbeiten] Anmerkungen
Der Standard empfiehlt, die an abs_time gebundene Uhr zum Messen der Zeit zu verwenden; diese Uhr muss keine monotone Uhr sein. Es gibt keine Garantien bezüglich des Verhaltens dieser Funktion, wenn die Uhr diskontinuierlich angepasst wird, aber die vorhandenen Implementierungen konvertieren abs_time von Clock zu std::chrono::system_clock und delegieren an POSIX pthread_cond_timedwait, sodass das Warten Anpassungen der Systemuhr berücksichtigt, aber nicht der vom Benutzer bereitgestellten Clock. In jedem Fall kann die Funktion aufgrund von Planungs- oder Ressourcenkonfliktverzögerungen auch länger als bis nach Erreichen von abs_time warten.
Selbst wenn die verwendete Uhr std::chrono::steady_clock oder eine andere monotone Uhr ist, kann eine Anpassung der Systemuhr eine Scheinnachricht auslösen.
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
#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) | |
| wait_until |
blockiert den aktuellen Thread, bis die Bedingungsvariable geweckt wird oder bis der angegebene Zeitpunkt erreicht ist (public member function) |
