Namensräume
Varianten
Aktionen

std::future<T>::wait_for

Von cppreference.com
< cpp‎ | thread‎ | future
 
 
Bibliothek für nebenläufige Programmierung
Threads
(C++11)
(C++20)
this_thread Namespace
(C++11)
(C++11)
(C++11)
Kooperatives Beenden
Gegenseitiger Ausschluss
(C++11)
Allgemeines Sperrungsmanagement
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Bedingungsvariablen
(C++11)
Semaphoren
Latches und Barriers
(C++20)
(C++20)
Futures
(C++11)
(C++11)
(C++11)
(C++11)
Sichere Wiederherstellung
(C++26)
Hazard Pointer
Atomare Typen
(C++11)
(C++20)
Initialisierung von atomaren Typen
(C++11)(veraltet in C++20)
(C++11)(veraltet in C++20)
Speicherordnung
(C++11)(deprecated in C++26)
Freie Funktionen für atomare Operationen
Freie Funktionen für atomare Flags
 
 
template< class Rep, class Period >
std::future_status wait_for( const std::chrono::duration<Rep,Period>& timeout_duration ) const;
(seit C++11)

Wartet, bis das Ergebnis verfügbar ist. Blockiert, bis die angegebene timeout_duration abgelaufen ist oder das Ergebnis verfügbar wird, je nachdem, was zuerst eintritt. Der Rückgabewert identifiziert den Zustand des Ergebnisses.

Wenn das Future das Ergebnis eines Aufrufs von std::async ist, das eine verzögerte Auswertung verwendet, gibt diese Funktion sofort zurück, ohne zu warten.

Diese Funktion kann aufgrund von Planungs- oder Ressourcenkonfliktverzögerungen länger als timeout_duration blockieren.

Der Standard empfiehlt die Verwendung einer stabilen Uhr zur Messung der Dauer. Wenn eine Implementierung stattdessen eine Systemuhr verwendet, kann die Wartezeit auch empfindlich auf Uhrenanpassungen reagieren.

Das Verhalten ist undefiniert, wenn valid() vor dem Aufruf dieser Funktion false ist.

Inhalt

[bearbeiten] Parameter

timeout_duration - maximale Dauer für das Blockieren

[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] Hinweise

Die Implementierungen werden ermutigt, den Fall zu erkennen, wenn valid == false vor dem Aufruf und eine std::future_error mit der Fehlerbedingung std::future_errc::no_state auszulösen.

[bearbeiten] Beispiel

#include <chrono>
#include <future>
#include <iostream>
#include <thread>
using namespace std::chrono_literals;
 
int main()
{
    std::future<int> future = std::async(std::launch::async, []()
    {
        std::this_thread::sleep_for(3s);
        return 8;
    });
 
    std::cout << "waiting...\n";
    std::future_status status;
 
    do
    {
        switch (status = future.wait_for(1s); status)
        {
            case std::future_status::deferred:
                std::cout << "deferred\n";
                break;
            case std::future_status::timeout:
                std::cout << "timeout\n";
                break;
            case std::future_status::ready:
                std::cout << "ready!\n";
                break;
        }
    }
    while (status != std::future_status::ready);
 
    std::cout << "result is " << future.get() << '\n';
}

Mögliche Ausgabe

waiting...
timeout
timeout
timeout
ready!
result is 8

[bearbeiten] Siehe auch

wartet, bis das Ergebnis verfügbar ist
(public member function) [bearbeiten]
wartet auf das Ergebnis, gibt zurück, wenn es nicht verfügbar ist, bis der angegebene Zeitpunkt erreicht ist
(public member function) [bearbeiten]