std::future<T>::wait_until
| template< class Clock, class Duration > std::future_status wait_until( const std::chrono::time_point<Clock,Duration>& timeout_time ) const; |
(seit C++11) | |
wait_until wartet darauf, dass ein Ergebnis verfügbar wird. Sie blockiert, bis die angegebene timeout_time erreicht ist oder das Ergebnis verfügbar wird, je nachdem, was zuerst eintritt. Der Rückgabewert gibt an, warum wait_until zurückgekehrt ist.
Wenn das Future das Ergebnis eines Aufrufs von async ist, das eine verzögerte Auswertung verwendet, gibt diese Funktion sofort zurück, ohne zu warten.
Das Verhalten ist undefiniert, wenn valid() vor dem Aufruf dieser Funktion false ist oder Clock die Clock-Anforderungen nicht erfüllt. Das Programm ist schlecht formuliert, wenn std::chrono::is_clock_v<Clock> false ist.(seit C++20)
Inhalt |
[bearbeiten] Parameter
| timeout_time | - | maximaler Zeitpunkt, bis zu dem blockiert werden soll |
[bearbeiten] Rückgabewert
| Konstante | Erklärung |
| future_status::deferred | Der gemeinsame Zustand enthält eine verzögerte Funktion, die eine verzögerte Auswertung verwendet, sodass das Ergebnis erst berechnet wird, wenn es explizit angefordert wird. |
| future_status::ready | Das Ergebnis ist verfügbar. |
| future_status::timeout | Der Timeout ist abgelaufen. |
[bearbeiten] Ausnahmen
Alle Ausnahmen, die von clock, time_point oder duration während der Ausführung ausgelöst werden (von der Standardbibliothek bereitgestellte Uhren, Zeitpunkte und Dauern lösen nie Ausnahmen aus).
[bearbeiten] Anmerkungen
Die Implementierungen werden ermutigt, den Fall zu erkennen, wenn valid() = false vor dem Aufruf und eine std::future_error mit der Fehlerbedingung future_errc::no_state auszulösen.
Der Standard empfiehlt, dass die an timeout_time gebundene Uhr zur Zeitmessung verwendet wird; 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 timeout_time von Clock nach std::chrono::system_clock und delegieren an POSIX pthread_cond_timedwait, so dass die Wartezeit Anpassungen der Systemuhr berücksichtigt, aber nicht die vom Benutzer bereitgestellten Clock. In jedem Fall kann die Funktion aufgrund von Planungs- oder Ressourcenkonfliktverzögerungen auch länger als bis nach Erreichen von timeout_time warten.
[bearbeiten] Beispiel
#include <chrono> #include <future> #include <iostream> #include <thread> int main() { std::chrono::system_clock::time_point two_seconds_passed = std::chrono::system_clock::now() + std::chrono::seconds(2); // Make a future that takes 1 second to complete std::promise<int> p1; std::future<int> f_completes = p1.get_future(); std::thread([](std::promise<int> p1) { std::this_thread::sleep_for(std::chrono::seconds(1)); p1.set_value_at_thread_exit(9); }, std::move(p1) ).detach(); // Make a future that takes 5 seconds to complete std::promise<int> p2; std::future<int> f_times_out = p2.get_future(); std::thread([](std::promise<int> p2) { std::this_thread::sleep_for(std::chrono::seconds(5)); p2.set_value_at_thread_exit(8); }, std::move(p2) ).detach(); std::cout << "Waiting for 2 seconds..." << std::endl; if (std::future_status::ready == f_completes.wait_until(two_seconds_passed)) std::cout << "f_completes: " << f_completes.get() << "\n"; else std::cout << "f_completes did not complete!\n"; if (std::future_status::ready == f_times_out.wait_until(two_seconds_passed)) std::cout << "f_times_out: " << f_times_out.get() << "\n"; else std::cout << "f_times_out did not complete!\n"; std::cout << "Done!\n"; }
Mögliche Ausgabe
Waiting for 2 seconds... f_completes: 9 f_times_out did not complete! Done!
[bearbeiten] Siehe auch
| wartet, bis das Ergebnis verfügbar ist (public member function) | |
| wartet auf das Ergebnis, gibt zurück, wenn es für die angegebene Zeitdauer nicht verfügbar ist (public member function) |
