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
Definido en el encabezado <future>
template < class T > class shared_future ;
(1) (desde C++11)
template < class T > class shared_future < T & > ;
(2) (desde C++11)
template <> class shared_future < void > ;
(3) (desde C++11)

La plantilla de clase std::shared_future proporciona un mecanismo para acceder al resultado de operaciones asíncronas, similar a std::future , con la excepción de que se permite que múltiples hilos esperen el mismo estado compartido. A diferencia de std::future , que solo es movable (por lo que solo una instancia puede referirse a cualquier resultado asíncrono particular), std::shared_future es copiable y múltiples objetos de futuro compartido pueden referirse al mismo estado compartido.

El acceso al mismo estado compartido desde múltiples hilos es seguro si cada hilo lo hace a través de su propia copia de un shared_future objeto.

Contenidos

Funciones miembro

construye el objeto future
(función miembro pública)
destruye el objeto future
(función miembro pública)
asigna el contenido
(función miembro pública)
Obteniendo el resultado
retorna el resultado
(función miembro pública)
Estado
verifica si el future tiene un estado compartido
(función miembro pública)
espera a que el resultado esté disponible
(función miembro pública)
espera el resultado, retorna si no está disponible después de la duración de timeout especificada
(función miembro pública)
espera el resultado, retorna si no está disponible hasta que se alcance el punto de tiempo especificado
(función miembro pública)

Ejemplo

Un shared_future puede utilizarse para señalar múltiples hilos simultáneamente, similar a std::condition_variable::notify_all() .

Ejecutar este código 
#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";
}

Salida posible: 

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

Véase también

(C++11)
ejecuta una función asincrónicamente (potencialmente en un nuevo hilo) y retorna un std::future que contendrá el resultado
(plantilla de función)
(C++11)
espera por un valor que se establece asincrónicamente
(plantilla de clase)