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

NAME
     std::shared_future - std::shared_future

Synopsis
	Defined in header <future>
	template< class T > class shared_future;     (1) (since C++11)
	template< class T > class shared_future<T&>; (2) (since C++11)
	template<> class shared_future<void>;	     (3) (since C++11)

	The class template std::shared_future provides a mechanism to access the
     result of
	asynchronous  operations,  similar  to std::future, except that multiple
     threads are
	allowed to wait for the same shared state. Unlike std::future, which  is
     only
	moveable  (so only one instance can refer to any particular asynchronous
     result),
	std::shared_future is copyable and multiple shared  future  objects  may
     refer to the
	same shared state.

	Access	to  the  same shared state from multiple threads is safe if each
     thread does it
	through its own copy of a shared_future object.

Member functions
	constructor   constructs the future object
		      (public member function)
	destructor    destructs the future object
		      (public member function)
	operator=     assigns the contents
		      (public member function)

Getting the result
	get	      returns the result
		      (public member function)

State
	valid	      checks if the future has a shared state
		      (public member function)
	wait	      waits for the result to become available
		      (public member function)
		      waits for the result, returns if it is not  available  for
     the specified
	wait_for      timeout duration
		      (public member function)
		      waits for the result, returns if it is not available until
     specified
	wait_until    time point has been reached
		      (public member function)

Example
	A  shared_future  may be used to signal multiple threads simultaneously,
     similar to
	std::condition_variable::notify_all().

     // Run this code

      #include <chrono>
      #include <future>
      #include <iostream>

      int main()
      {
	  std::promise<void> ready_promise, t1_ready_promise, t2_ready_promise;
	  std::shared_future<void> ready_future(ready_promise.get_future());

	  std::chrono::time_point<std::chrono::high_resolution_clock> start;

	  auto	fun1  =  [&,  ready_future]()  ->  std::chrono::duration<double,
     std::milli>
	  {
	      t1_ready_promise.set_value();
	      ready_future.wait(); // waits for the signal from main()
	      return std::chrono::high_resolution_clock::now() - start;
	  };

	  auto	fun2  =  [&,  ready_future]()  ->  std::chrono::duration<double,
     std::milli>
	  {
	      t2_ready_promise.set_value();
	      ready_future.wait(); // waits for the signal from main()
	      return std::chrono::high_resolution_clock::now() - start;
	  };

	  auto fut1 = t1_ready_promise.get_future();
	  auto fut2 = t2_ready_promise.get_future();

	  auto result1 = std::async(std::launch::async, fun1);
	  auto result2 = std::async(std::launch::async, fun2);

	  // wait for the threads to become ready
	  fut1.wait();
	  fut2.wait();

	  // the threads are ready, start the clock
	  start = std::chrono::high_resolution_clock::now();

	  // signal the threads to go
	  ready_promise.set_value();

	  std::cout << "Thread 1 received the signal "
		    << result1.get().count() << " ms after start\n"
		    << "Thread 2 received the signal "
		    << result2.get().count() << " ms after start\n";
      }

Possible output:
      Thread 1 received the signal 0.072 ms after start
      Thread 2 received the signal 0.041 ms after start

See also
	async	runs a function asynchronously (potentially in a new thread) and
     returns a
	(C++11) std::future that will hold the result
		(function template)
	future	waits for a value that is set asynchronously
	(C++11) (class template)

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