Futures vs. Promises

Question

Dezorientuję się różnicą między przyszłością a obietnicą.

Oczywiście, mają różne metody i rzeczy, ale jaki jest rzeczywisty przypadek użycia?

Czy ?:

• kiedy jestem zarządzający jakieś zadanie asynchronicznej, używam przyszłość, aby uzyskać wartość „w przyszłości”
• kiedy jestem zadanie asynchroniczny, używam jako obietnicę typ zwrotu, aby użytkownik mógł uzyskać przyszłość dzięki mojej obietnicy.

Answer 1

Przyszłość i obietnica to dwie oddzielne strony operacji asynchronicznej.

std::promise jest używany przez „producent/scenarzysta” asynchronicznego operacji.

std::future jest używany przez „konsumenta/czytelnika” w asynchronicznej operacji.

Powodem jest podzielone na tych dwóch oddzielnych „interfejsów” jest hide „Write/set” funkcjonalności z „konsument/czytelnika”.

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

One (niekompletny) sposobem wdrożenia std :: asynchroniczny przy użyciu std :: obietnica może być:

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

Korzystanie std::packaged_task który jest pomocnika (czyli po prostu robi to, co robiliśmy powyżej) wokół std::promise można wykonać następujące czynności, która jest bardziej kompletny i ewentualnie szybciej:

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

Zauważ, że ten jest nieco inny od std::async gdzie zwrócony std::future po zniszczeniu faktycznie zablokuje się, aż wątek zostanie zakończony.