Futures vs. Promises

Question

Me estoy confundiendo con la diferencia entre un futuro y una promesa.

Obviamente, tienen diferentes métodos y otras cosas, pero ¿cuál es el caso de uso real?

es ?:

• cuando estoy gestión alguna tarea asíncrona, lo uso futuro para obtener el valor "en el futuro"
• cuando estoy la tarea asíncrona, utilizo promesa como la tipo de devolución para permitir al usuario obtener un futuro de mi promesa

Answer 1

Futuro y promesa son los dos lados separados de una operación asincrónica.

std::promise es utilizado por el "productor/escritor" de la operación asincrónica.

std::future es utilizado por el "consumidor/lector" de la operación asincrónica.

El motivo por el que está separado en estas dos "interfaces" separadas es ocultar la funcionalidad "escribir/configurar" del "consumidor/lector".

auto promise = std::promise<std::string>(); 

auto producer = std::thread([&] 
{ 
    promise.set_value("Hello World"); 
}); 

auto future = promise.get_future(); 

auto consumer = std::thread([&] 
{ 
    std::cout << future.get(); 
}); 

producer.join(); 
consumer.join(); 

Una forma (incompleta) para implementar std :: asíncrono utilizando std :: promesa podría ser:

template<typename F> 
auto async(F&& func) -> std::future<decltype(func())> 
{ 
    typedef decltype(func()) result_type; 

    auto promise = std::promise<result_type>(); 
    auto future = promise.get_future(); 

    std::thread(std::bind([=](std::promise<result_type>& promise) 
    { 
     try 
     { 
      promise.set_value(func()); // Note: Will not work with std::promise<void>. Needs some meta-template programming which is out of scope for this question. 
     } 
     catch(...) 
     { 
      promise.set_exception(std::current_exception()); 
     } 
    }, std::move(promise))).detach(); 

    return std::move(future); 
} 

Usando std::packaged_task que es un ayudante (es decir, que básicamente hace lo que hacíamos anteriormente) alrededor de std::promise que podría hacer lo siguiente, que es más completa y posiblemente más rápido:

template<typename F> 
auto async(F&& func) -> std::future<decltype(func())> 
{ 
    auto task = std::packaged_task<decltype(func())()>(std::forward<F>(func)); 
    auto future = task.get_future(); 

    std::thread(std::move(task)).detach(); 

    return std::move(future); 
} 

Tenga en cuenta que esto es ligeramente diferente de std::async donde el std::future devuelto se bloqueará cuando se destruya hasta que el hilo termine.