webentwicklung-frage-antwort-db.com.de

Futures vs. Versprechen

Ich verwechsle mich mit dem Unterschied zwischen einer Zukunft und einem Versprechen.

Offensichtlich haben sie verschiedene Methoden und Dinge, aber was ist der tatsächliche Anwendungsfall?

Ist es?:

  • wenn ich eine asynchrone Aufgabe verwalte, verwende ich future, um den Wert "in future" zu erhalten.
  • wenn ich die asynchrone Aufgabe bin, verwende ich Versprechen als Rückgabetyp, damit der Benutzer eine Zukunft aus meinem Versprechen ziehen kann
118
Let_Me_Be

Zukunft und Verheißung sind die beiden getrennten Seiten einer asynchronen Operation.

std::promise wird vom "Producer/Writer" der asynchronen Operation verwendet.

std::future wird vom "Consumer/Reader" der asynchronen Operation verwendet.

Der Grund, warum es in diese beiden getrennten "Schnittstellen" unterteilt ist, ist verstecken die "Write/Set" -Funktionalität vom "Consumer/Reader".

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

Eine (unvollständige) Möglichkeit, std :: async mit std :: promise zu implementieren, könnte sein:

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

Mit std::packaged_task das ist ein Helfer (d. h. es macht im Grunde das, was wir oben gemacht haben) um std::promise Sie könnten Folgendes tun, was vollständiger und möglicherweise schneller ist:

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

Beachten Sie, dass dies etwas anders ist als std::async wo der zurückgegeben std::future wird, wenn es zerstört ist, tatsächlich blocken, bis der Thread beendet ist.

152
ronag