Namespaces
Variants

std:: shared_future

From cppreference.net
C++
Concurrency support library
Threads
(C++11)
(C++20)
(C++17) (C++17)
this_thread namespace
(C++11)
(C++11)
Cooperative cancellation
Mutual exclusion
Generic lock management
Condition variables
(C++11)
(C++11)
(C++11)
(C++11)
Semaphores
(C++20) (C++20)
Latches and Barriers
(C++20)
(C++20)
Futures
(C++11)
(C++11)
shared_future
(C++11)
(C++11)
(C++11)
Safe reclamation
Hazard pointers
(C++26)
(C++26)
(C++26)
Atomic types
(C++11)
(C++20)
(C++11)
Initialization of atomic types
(C++11) (deprecated in C++20)
(C++11) (deprecated in C++20)
(C++11)
Memory ordering
(C++11)
(C++11) (deprecated in C++26)
(C++11)
(C++11)
Free functions for atomic operations
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11) (C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++26) (C++26)
(C++26) (C++26)
(C++11)
(C++20) (C++20)
(C++20)
(C++20)
Free functions for atomic flags
(C++11) (C++11)
(C++11) (C++11)
(C++20) (C++20)
(C++20) (C++20)
(C++20)
(C++20)
std::shared_future
Определено в заголовочном файле <future>
template < class T > class shared_future ;
(1) (начиная с C++11)
template < class T > class shared_future < T & > ;
(2) (начиная с C++11)
template <> class shared_future < void > ;
(3) (начиная с C++11)

Шаблон класса std::shared_future предоставляет механизм для доступа к результату асинхронных операций, аналогично std::future , за исключением того, что нескольким потокам разрешено ожидать одно общее состояние. В отличие от std::future , который является только перемещаемым (поэтому только один экземпляр может ссылаться на любой конкретный асинхронный результат), std::shared_future является копируемым, и несколько объектов shared future могут ссылаться на одно общее состояние.

Доступ к одному и тому же общему состоянию из нескольких потоков безопасен, если каждый поток осуществляет его через свою собственную копию объекта shared_future .

Содержание

Функции-члены

конструирует объект future
(public member function)
уничтожает объект future
(public member function)
присваивает содержимое
(public member function)
Получение результата
возвращает результат
(public member function)
Состояние
проверяет, имеет ли future общее состояние
(public member function)
ожидает доступности результата
(public member function)
ожидает результат, возвращает управление, если он недоступен в течение указанного времени ожидания
(public member function)
ожидает результат, возвращает управление, если он недоступен до достижения указанной точки времени
(public member function)

Пример

Объект shared_future может использоваться для одновременного уведомления нескольких потоков, аналогично std::condition_variable::notify_all() .

Запустить этот код 
#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";
}

Возможный вывод: 

Thread 1 received the signal 0.072 ms after start
Thread 2 received the signal 0.041 ms after start

Смотрите также

(C++11)
запускает функцию асинхронно (потенциально в новом потоке) и возвращает std::future , который будет содержать результат
(шаблон функции)
(C++11)
ожидает значение, которое устанавливается асинхронно
(шаблон класса)