std :: वादा <T> धागा-सुरक्षित है?

Question

क्या यह के लिए के लिए mutable बनाने के लिए सुरक्षित है, या यह T पर निर्भर करता है? में के रूप में:

using Data = std::tuple<bool, int, int>; 

struct X { 

    std::future<Data> prepare() const { 
     return m_promise.get_future(); 
    } 

    void asyncHandler(int a, int b) const { 
     m_promise.set_value({true, a, b}); 
    } 

    void cancel() const { 
     m_promise.set_value({false, 0, 0}); 
    } 

    mutable std::promise<Data> m_promise; // Is this safe? 
}; 


void performAsyncOp(const X& x) { 
    std::future<Data> fut = x.prepare(); 
    dispatch(x); 
    std::future_status result = fut.wait_for(std::chrono::milliseconds(150)); 
    if (result == std::future_status::timeout) { 
     x.cancel(); 
    } 

    handleResult(fut.get()); 
} 

Answer 1

चलो एपीआई को विस्तार से देखा है:

// retrieving the result 
future<R> get_future(); 

// setting the result 
void set_value(see below); 
void set_exception(exception_ptr p); 

// setting the result with deferred notification 
void set_value_at_thread_exit(see below); 
void set_exception_at_thread_exit(exception_ptr p); 

तरीकों में से कोई भी const चिह्नित है, तो हम सिर्फ इस से constness बारे में कोई जानकारी अनुमान नहीं लगा सकता। हालांकि, निम्न विधियों पर मानक जरूरी थ्रेड-सुरक्षा (सी.एफ. 33.6.6.2): set_­value, set_­exception, set_­value_­at_­thread_­exit, और set_­exception_­at_­thread_­exit।

यह get_future थ्रेड-सुरक्षा के संबंध में निर्दिष्ट नहीं है। हालांकि, get_future एक अपवाद फेंकता है अगर एक से अधिक बार कहा जाता है, सीएफ। 33.6.6.14.1। तो एकाधिक धागे से get_future पर कॉल करना वास्तव में व्यावहारिक दृष्टिकोण से समझ में नहीं आता है।

धागे की सुरक्षा के लिए कोई गारंटी नहीं है जब get_future और किसी भी set तरीकों की और get_future बुला (कोई फर्क नहीं पड़ता अगर यह फेंक देते हैं या नहीं) एक साथ, जहाँ तक मैं देख सकते हैं।