std::shared_future<T>::wait_for

template< class Rep, class Period > std::future_status wait_for( const std::chrono::duration<Rep,Period>& timeout_duration ) const;		(since C++11)

Waits for the result to become available. Blocks until specified timeout_duration has elapsed or the result becomes available, whichever comes first. Returns value identifies the state of the result.

This function may block for longer than timeout_duration due to scheduling or resource contention delays.

The standard recommends that a steady clock is used to measure the duration. If an implementation uses a system clock instead, the wait time may also be sensitive to clock adjustments.

The behavior is undefined if valid()== false before the call to this function.

Parameters

timeout_duration

-

maximum duration to block for

Return value

Constant	Explanation
`future_status::deferred`	The function to calculate the result has not been started yet
`future_status::ready`	The result is ready
`future_status::timeout`	The timeout has expired

Exceptions

Any exception thrown by clock, time_point, or duration during the execution (clocks, time points, and durations provided by the standard library never throw)

Notes

The implementations are encouraged to detect the case when valid == false before the call and throw a future_error with an error condition of future_errc::no_state.

Example

Run this code

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

Possible output:

waiting...
timeout
timeout
ready!
result is 8

Language
Standard Library Headers
Freestanding and hosted implementations
Named requirements
Language support library
Concepts library (C++20)
Diagnostics library
Utilities library
Strings library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Numerics library
Input/output library
Localizations library
Regular expressions library (C++11)
Atomic operations library (C++11)
Thread support library (C++11)
Filesystem library (C++17)
Technical Specifications

Member functions
shared_future::shared_future
shared_future::~shared_future
shared_future::operator=
Getting the result
shared_future::get
State
shared_future::valid
shared_future::wait
shared_future::wait_for
shared_future::wait_until