El archivo de encabezado <future> contiene las siguientes clases y funciones:

Proveedores 类： std :: promise, std :: package_task
Futuros 类： std :: futuro, shared_future.
Función de proveedores: std :: async ()
其他类型： std :: future_error, std :: future_errc, std :: future_status,
std :: launch.

Introducción a la clase std :: promise

Un objeto de promesa puede almacenar un valor de cierto tipo T, que puede ser leído por un objeto futuro (posiblemente en otro hilo), por lo que las promesas también proporcionan un medio de sincronización de hilo. Cuando se construye el objeto de promesa, se puede asociar con un estado compartido (generalmente std :: future), y un valor de tipo T se puede almacenar en el estado compartido asociado (std :: future).
Puede obtener el objeto futuro asociado con el objeto de promesa a través de get_future. Después de llamar a esta función, los dos objetos comparten el mismo estado compartido.

El objeto de promesa es un proveedor asincrónico, que puede establecer el valor del estado compartido en un momento determinado.
El objeto futuro puede devolver el valor del estado compartido de forma asincrónica o, si es necesario, bloquear a la persona que llama y esperar a que la bandera de estado compartido esté lista antes de obtener el valor del estado compartido.

Aquí hay un ejemplo simple para ilustrar la relación anterior:

#include <iostream>       // std::cout
#include <functional>     // std::ref
#include <thread>         // std::thread
#include <future>         // std::promise, std::future

void print_int(std::future<int>& fut) {
    
    
    int x = fut.get(); // 获取共享状态的值.
    std::cout << "value: " << x << '\n'; // 打印 value: 10.
}

int main ()
{
    
    
    std::promise<int> prom; // 生成一个 std::promise<int> 对象.
    std::future<int> fut = prom.get_future(); // 和 future 关联.
    std::thread t(print_int, std::ref(fut)); // 将 future 交给另外一个线程t.
    
    prom.set_value(10); // 设置共享状态的值, 此处和线程t保持同步.
    std::cout << "set value 10" << std::endl;
    
    t.join();
    
    return 0;
}

std :: constructor de promesas

defecto	promesa();
con asignador	promesa de plantilla (allocator_arg_t aa, const Alloc & alloc);
copiar [eliminado]	promesa (promesa constante &) = eliminar;
Muevete	promesa (promesa && x) no excepto;

El constructor predeterminado inicializa un estado compartido vacío.
El constructor con un asignador de memoria personalizado es similar al constructor predeterminado, pero usa un asignador personalizado para asignar el estado compartido.
El constructor de copias está deshabilitado.
Mover constructor.

Además, operator = de std :: promise no tiene semántica de copia, es decir, las operaciones de asignación ordinarias de std :: promise están deshabilitadas y operator = solo tiene semántica de movimiento, por lo que los objetos std :: promise están prohibidos para copiar.

ejemplo:

#include <iostream>       // std::cout
#include <thread>         // std::thread
#include <future>         // std::promise, std::future

std::promise<int> prom;

void print_global_promise() {
    
    
    std::future<int> fut = prom.get_future();
    int x = fut.get();
    std::cout << "value: " << x << '\n';
}

int main()
{
    
    
    std::thread th1(print_global_promise);
    prom.set_value(10);
    th1.join();

    prom = std::promise<int>();    // prom 被move赋值为一个新的 promise 对象.

    std::thread th2 (print_global_promise);
    prom.set_value (20);
    th2.join();

    return 0;
}

std :: promise :: get_future 介绍

Esta función devuelve un futuro asociado con el estado compartido de la promesa. El objeto futuro devuelto puede acceder al valor establecido en el estado compartido por el objeto de promesa o un objeto de excepción. Solo se puede obtener un objeto futuro del estado de promesa compartida. Después de llamar a esta función, el objeto de promesa generalmente está listo en un momento determinado (establezca un valor o un objeto de excepción). Si el valor o la excepción no se establece, el objeto de promesa establecerá automáticamente una excepción de error futuro (promesa_rompida) cuando se destruye Para establecer su propio estado listo. El get_future se ha mencionado en el ejemplo anterior, por lo que no lo repetiré aquí.

Introducción a std :: promise :: set_value

Establezca el valor del estado compartido, después del cual la bandera de estado compartido de la promesa estará lista.

Introducción a std :: promise :: set_exception

Establezca una excepción para la promesa. Después de eso, el estado compartido de la promesa estará listo. Por ejemplo, el hilo 1 recibe un número entero de la terminal y el hilo 2 imprime el número entero. Si el hilo 1 recibe un número no entero, establezca un excepción para la promesa (failbit), el hilo 2 lanza la excepción en std :: future :: get.

#include <iostream>       // std::cin, std::cout, std::ios
#include <functional>     // std::ref
#include <thread>         // std::thread
#include <future>         // std::promise, std::future
#include <exception>      // std::exception, std::current_exception

void get_int(std::promise<int>& prom) {
    
    
    int x;
    std::cout << "Please, enter an integer value: ";
    std::cin.exceptions (std::ios::failbit);   // throw on failbit
    try {
    
    
        std::cin >> x;                         // sets failbit if input is not int
        prom.set_value(x);
    } catch (std::exception&) {
    
    
        prom.set_exception(std::current_exception());
    }
}

void print_int(std::future<int>& fut) {
    
    
    try {
    
    
        int x = fut.get();
        std::cout << "value: " << x << '\n';
    } catch (std::exception& e) {
    
    
        std::cout << "[exception caught: " << e.what() << "]\n";
    }
}

int main ()
{
    
    
    std::promise<int> prom;
    std::future<int> fut = prom.get_future();

//    std::thread th1(get_int, std::ref(prom));
    std::thread th2(print_int, std::ref(fut));
    std::thread th1(get_int, std::ref(prom));

    th1.join();
    th2.join();
    
    return 0;
}

std :: promise :: set_value_at_thread_exit 介绍

Establezca el valor del estado compartido, pero no establezca el indicador del estado compartido en listo, el objeto de promesa se establecerá automáticamente en listo cuando el hilo salga. Si un objeto std :: future está asociado con el estado compartido del objeto de promesa, y el futuro llama a get, el hilo que llama a get se bloqueará. Cuando el hilo salga, el hilo que llama a future :: get se desbloqueará y al mismo tiempo, get devuelve el valor establecido por set_value_at_thread_exit. Tenga en cuenta que esta función ya ha establecido el valor del estado compartido de la promesa. Si hay otras operaciones para establecer o modificar el valor del estado compartido antes de que finalice el hilo, se lanzará future_error (promise_already_satisfied).

Introducción a std :: promise :: swap

Intercambie el estado compartido de promesas.

Guía de concurrencia de C ++ <futuro> (1) std :: promise