फ्यूचर्स बनाम वादे

Question

मैं भविष्य और एक वादे के बीच अंतर के साथ खुद को भ्रमित कर रहा हूं।

जाहिर है, उनके पास विभिन्न विधियां और सामान हैं, लेकिन वास्तविक उपयोग केस क्या है?

यह

• ?: जब मैं कुछ async कार्य प्रबंध कर रहा हूँ है, मैं भविष्य का उपयोग करें "भविष्य में" मूल्य प्राप्त करने के
• जब मैं async कार्य हूँ, मैं के रूप में वादा का उपयोग उपयोगकर्ता को मेरे वादे से भविष्य प्राप्त करने की अनुमति देने के लिए वापसी प्रकार

Answer 1

भविष्य और वादा एक असीमित संचालन के दो अलग-अलग पक्ष हैं।

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

एक (अधूरा) जिस तरह से लागू करने के लिए एसटीडी :: एसटीडी का उपयोग कर async :: वादा हो सकता है:

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::async से थोड़ा भिन्न है

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::promise चारों ओर आप जिसके बाद और अधिक पूर्ण और संभवतः तेजी से होता है कर सकता है जहां std::future वापस आ जाएगा जब वास्तव में धागा समाप्त हो जाता है तब तक अवरुद्ध हो जाता है।