Futures vs. Promises

Question

Mi sto confondendo con la differenza tra un futuro e una promessa.

Ovviamente, hanno metodi e cose diversi, ma qual è il caso d'uso effettivo?

E '?:

• quando sto gestire un compito asincrono, io uso futuro per ottenere il valore "in futuro"
• quando sono il compito asincrono, io uso promessa come il restituire il tipo per consentire all'utente di ottenere un futuro dalla mia promessa

Answer 1

Future e Promise sono i due lati separati di un'operazione asincrona.

std::promise viene utilizzato dal "produttore/scrittore" dell'operazione asincrona.

std::future viene utilizzato dal "consumatore/lettore" dell'operazione asincrona.

Il motivo per cui è separato in queste due "interfacce" separate è nasconde la funzionalità "scrittura/imposta" dal "consumatore/lettore".

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(); 

Un modo (incompleto) per implementare std :: asincrona utilizzando std :: promessa potrebbe essere:

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); 
} 

Utilizzando std::packaged_task che è un aiutante (vale a dire che fondamentalmente fa quello che stavamo facendo sopra) intorno std::promise si potrebbe fare la seguente che è più completo e possibilmente più veloce:

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); 
} 

si noti che questo è leggermente diverso da std::async dove viene restituito il std::future restituito quando viene effettivamente bloccato fino al termine del thread.