Futures a obietnice

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

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

Czy to jest ?:

• kiedy zarządzam jakimś zadaniem asynchronicznym, używam przyszłości, aby uzyskać wartość „w przyszłości”
• kiedy jestem zadaniem asynchronicznym, używam obietnicy jako typu zwracanego, aby umożliwić użytkownikowi uzyskanie przyszłości z mojej obietnicy

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

std::promise jest używany przez „producenta / piszącego” operacji asynchronicznej.

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

Powodem, dla którego jest on podzielony na te dwa oddzielne „interfejsy”, jest ukrycie funkcji „zapis / ustaw” przed „konsumentem / czytelnikiem”.

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

Jednym (niekompletnym) sposobem zaimplementowania std :: async przy użyciu std :: promise 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);
}

Używając std::packaged_taskwhich jest pomocnikiem (czyli zasadniczo robi to, co robiliśmy powyżej) wokół std::promiseciebie możesz wykonać następujące czynności, które są bardziej kompletne i prawdopodobnie szybsze:

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 jest to nieco inne niż miejsce, w std::asyncktórym zwrócony std::futurewill po zniszczeniu faktycznie blokuje, aż wątek zostanie zakończony.