home | help 
std::future::wait_for(3)       C++ Standard Libary	std::future::wait_for(3)

NAME
     std::future::wait_for - std::future::wait_for

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

	Waits for the result to become available. Blocks until	specified  time-
     out_duration
	has  elapsed or the result becomes available, whichever comes first. The
     return value
	identifies the state of the result.

	If the future is the result of a call to std::async that used lazy eval-
     uation, this
	function returns immediately without waiting.

	This function may block for longer than timeout_duration due to schedul-
     ing or
	resource contention delays.

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

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

Parameters
	timeout_duration - maximum duration to block for

Return value
	Constant		Explanation
				The shared state contains  a  deferred	function
     using lazy
	future_status::deferred  evaluation, so the result will be computed only
     when
				explicitly requested
	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 execu-
     tion (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 std::future_error with an error condition of
	std::future_errc::no_state.

Example
     // Run this code

      #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';
      }

Possible output:
      waiting...
      timeout
      timeout
      timeout
      ready!
      result is 8

See also
	wait	   waits for the result to become available
		   (public member function)
		   waits for the result, returns if it is  not	available  until
     specified time
	wait_until point has been reached
		   (public member function)

http://cppreference.com 	   2024.06.10		std::future::wait_for(3)
home | help