std::future<T>:: wait_until

wait_until wartet darauf, dass ein Ergebnis verfügbar wird. Es blockiert, bis der angegebene timeout_time erreicht wurde oder das Ergebnis verfügbar wird, je nachdem, was zuerst eintritt. Der Rückgabewert gibt an, warum wait_until zurückgekehrt ist.

Wenn die Zukunft das Ergebnis eines Aufrufs von async mit verzögerter Auswertung ist, kehrt 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 fehlerhaft, wenn std:: chrono :: is_clock_v < Clock > false ist. (seit C++20)

Parameter

Rückgabewert

Ausnahmen

Jede Ausnahme, die von clock, time_point oder duration während der Ausführung geworfen wird (von der Standardbibliothek bereitgestellte Uhren, Zeitpunkte und Zeitdauern werfen niemals).

Hinweise

Die Implementierungen sind angehalten, den Fall zu erkennen, wenn valid ( ) == false vor dem Aufruf und eine std::future_error mit einem Fehlerzustand von future_errc::no_state zu werfen.

Der Standard empfiehlt, dass die an timeout_time gebundene Uhr zur Zeitmessung verwendet wird; diese Uhr muss kein monotones Zeitgeber sein. Es gibt keine Garantien bezüglich des Verhaltens dieser Funktion, wenn die Uhr diskontinuierlich angepasst wird, aber die bestehenden Implementierungen konvertieren timeout_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 die benutzerbereitgestellte Clock . In jedem Fall kann die Funktion auch länger warten, als bis timeout_time erreicht wurde, aufgrund von Planungs- oder Ressourcenkonfliktverzögerungen.

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);
    // Erstelle ein Future, das 1 Sekunde zur Fertigstellung benötigt
    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();
    // Erstelle ein Future, das 5 Sekunden zur Fertigstellung benötigt
    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 << "Warte 2 Sekunden..." << 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 wurde nicht fertig!\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 wurde nicht fertig!\n";
    std::cout << "Fertig!\n";
}

Warte 2 Sekunden...
f_completes: 9
f_times_out wurde nicht fertig!
Fertig!

Siehe auch