Ф'ючерси проти обіцянок

Я плутаю себе в різниці між майбутнім і обіцянкою.

Очевидно, у них є різні способи та інше, але який фактичний випадок використання?

Є це?:

• коли я керую деяким завданням асинхронізації, я використовую майбутнє, щоб отримати значення "у майбутньому"
• коли я завдання async, я використовую обіцянку як тип повернення, щоб дозволити користувачеві отримати майбутнє від моєї обіцянки

Майбутнє та обіцянка - це дві окремі сторони асинхронної операції.

std::promise використовується "продюсером / письменником" асинхронної операції.

std::future використовується "споживачем / читачем" асинхронної операції.

Причина, по якій він розділений на ці два окремих "інтерфейси", полягає в тому, щоб приховати функцію "написати / встановити" від "споживача / читача".

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

Одним (неповним) способом реалізації std :: async за допомогою std :: obeze може бути:

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

Використовуючи std::packaged_taskпомічник (тобто в основному він робить те, що ми робили вище) навколо std::promiseвас, можна зробити наступне, що є більш повним і, можливо, швидшим:

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

Зауважте, що це трохи відрізняється від того, std::asyncде повернута std::futureволя при знищенні насправді блокується, поки нитка не буде закінчена.