std::shared_future - cppreference.com

##### cppreference.com

##### Search

Create account

##### Namespaces

- Page
- Discussion

##### Variants

##### Views

- View
- Edit
- History

##### Actions

# std::shared_future

From cppreference.com
< cpp‎ | thread

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)

| This section is incomplete

### [edit] 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) [edit]
##### State
valid | checks if the future has a shared state (public member function) [edit]
wait | waits for the result to become available (public member function) [edit]
wait_for | waits for the result, returns if it is not available for the specified timeout duration (public member function) [edit]
wait_until | waits for the result, returns if it is not available until specified time point has been reached (public member function) [edit]

### [edit] Example

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

Run this code

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

    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 = [&]() -> 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 = [&]() -> 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 result1 = std::async(std::launch::async, fun1);
        auto result2 = std::async(std::launch::async, fun2);

        // wait for the threads to become ready
        t1_ready_promise.get_future().wait();
        t2_ready_promise.get_future().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

Retrieved from "http://en.cppreference.com/mwiki/index.php?title=cpp/thread/shared_future&oldid=62979"
Category:

- Todo without reason