std:: promise

La plantilla de clase std::promise proporciona un mecanismo para almacenar un valor o una excepción que posteriormente se adquiere de forma asíncrona a través de un objeto std::future creado por el objeto std::promise . Nótese que el objeto std::promise está diseñado para ser utilizado una sola vez.

Cada promesa está asociada con un estado compartido , que contiene cierta información de estado y un resultado que puede no estar evaluado aún, evaluado a un valor (posiblemente void) o evaluado a una excepción. Una promesa puede hacer tres cosas con el estado compartido:

• make ready : la promesa almacena el resultado o la excepción en el estado compartido. Marca el estado como listo y desbloquea cualquier hilo que esté esperando en un future asociado al estado compartido.
• release : la promesa renuncia a su referencia al estado compartido. Si esta era la última referencia de este tipo, el estado compartido se destruye. A menos que se tratara de un estado compartido creado por std:: async que aún no esté listo, esta operación no se bloquea.
• abandon : la promesa almacena la excepción de tipo std::future_error con código de error std::future_errc::broken_promise , hace que el estado compartido esté ready , y luego lo releases .

La promesa es el extremo de "empuje" del canal de comunicación promesa-futuro: la operación que almacena un valor en el estado compartido sincroniza-con (como se define en std::memory_order ) el retorno exitoso de cualquier función que esté esperando en el estado compartido (como std::future::get ). El acceso concurrente al mismo estado compartido puede generar conflictos de otra manera: por ejemplo, múltiples llamadas a std::shared_future::get deben ser todas de solo lectura o proporcionar sincronización externa.

Funciones miembro

Funciones no miembro

Clases auxiliares

Ejemplo

#include <chrono>
#include <future>
#include <iostream>
#include <numeric>
#include <thread>
#include <vector>
void accumulate(std::vector<int>::iterator first,
                std::vector<int>::iterator last,
                std::promise<int> accumulate_promise)
{
    int sum = std::accumulate(first, last, 0);
    accumulate_promise.set_value(sum); // Notificar future
}
void do_work(std::promise<void> barrier)
{
    std::this_thread::sleep_for(std::chrono::seconds(1));
    barrier.set_value();
}
int main()
{
    // Demostrar el uso de promise<int> para transmitir un resultado entre hilos.
    std::vector<int> numbers = {1, 2, 3, 4, 5, 6};
    std::promise<int> accumulate_promise;
    std::future<int> accumulate_future = accumulate_promise.get_future();
    std::thread work_thread(accumulate, numbers.begin(), numbers.end(),
                            std::move(accumulate_promise));
    // future::get() esperará hasta que el future tenga un resultado válido y lo recuperará.
    // No es necesario llamar a wait() antes de get()
    // accumulate_future.wait(); // esperar por el resultado
    std::cout << "result=" << accumulate_future.get() << '\n';
    work_thread.join(); // esperar por la finalización del hilo
    // Demostrar el uso de promise<void> para señalizar estado entre hilos.
    std::promise<void> barrier;
    std::future<void> barrier_future = barrier.get_future();
    std::thread new_work_thread(do_work, std::move(barrier));
    barrier_future.wait();
    new_work_thread.join();
}

result=21