ฟิวเจอร์สกับสัญญา

ฉันสับสนกับความแตกต่างระหว่างอนาคตกับคำสัญญา

เห็นได้ชัดว่าพวกเขามีวิธีการและสิ่งต่าง ๆ แต่กรณีการใช้งานจริงเป็นอย่างไร?

ใช่ไหม?:

• เมื่อฉันจัดการงาน async ฉันใช้อนาคตเพื่อรับค่า "ในอนาคต"
• เมื่อฉันเป็นงาน 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 :: สัญญาอาจเป็น:

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ประสงค์ที่ส่งคืนเมื่อทำลายจริงบล็อกจนกว่าเธรดจะเสร็จสิ้น