क्या मुझे अस्थिर कीवर्ड का उपयोग करने की आवश्यकता है यदि मैं म्यूटेक्स के बीच एक चर घोषित करता हूं और इसे वापस करता हूं?

Question

मान लें कि मेरे पास निम्न कार्य है।

std::mutex mutex; 

int getNumber() 
{ 
    mutex.lock(); 
    int size = someVector.size(); 
    mutex.unlock(); 
    return size; 
} 

क्या यह आकार घोषित करते समय volatile कीवर्ड का उपयोग करने का स्थान है? अगर मैं अस्थिरता का उपयोग नहीं करता तो मूल्य अनुकूलन वापस लौटाएगा या कुछ और इस कोड को तोड़ देगा? someVector का आकार प्रोग्राम के कई धागे से बदला जा सकता है और यह माना जाता है कि केवल एक धागा (संशोधक के अलावा) getNumber() पर कॉल करता है।

Answer 1

आपने उल्लेख नहीं किया है कि mutex चर का प्रकार क्या है, लेकिन यह मानते हुए कि यह std::mutex (या पारस्परिक बहिष्करण की गारंटी देने के लिए समान कुछ है), संकलक को कई अनुकूलन करने से रोका गया है। इसलिए आपको वापसी मूल्य अनुकूलन या कुछ अन्य अनुकूलन के बारे में चिंता करने की आवश्यकता नहीं है, जो size() क्वेरी को म्यूटेक्स ब्लॉक के बाहर निष्पादित करने की इजाजत देता है।

हालांकि, जैसे ही म्युटेक्स ताला जारी की है, एक और प्रतीक्षा धागा वेक्टर पहुँच सकते हैं और संभवतः यह उत्परिवर्तित, इस प्रकार आकार बदलने के लिए स्वतंत्र है। अब, आपके फ़ंक्शन द्वारा लौटाई गई संख्या पुरानी है। चूंकि मैट पीटर्ससन ने अपने answer में उल्लेख किया है, यदि यह कोई मुद्दा है, तो म्यूटेक्स लॉक को getNumber() के कॉलर द्वारा अधिग्रहित करने की आवश्यकता है, और जब तक कॉलर परिणाम का उपयोग नहीं कर लेता है तब तक आयोजित किया जाता है। इससे यह सुनिश्चित होगा कि ऑपरेशन के दौरान वेक्टर का आकार बदल नहीं जाता है।

---

स्पष्ट रूप से कॉल करना mutex::lockmutex::unlock के बाद जल्दी से अपवाद हैं, कई वापसी बयान आदि एक बहुत आसान विकल्प म्युटेक्स ताला प्राप्त करने के लिए std::lock_guard उपयोग करने के लिए है को शामिल और अधिक जटिल कार्यों के लिए अव्यावहारिक हो जाता है।

int getNumber() 
{ 
    std::lock_guard<std::mutex> l(mutex); // lock is acquired 
    int size = someVector.size(); 
    return size; 
} // lock is released automatically when l goes out of scope 

Answer 2

नहीं। लेकिन सावधान रहना है कि size वास्तविक आकार प्रतिबिंबित नहीं कर सकते बाद म्युटेक्स जारी किया गया है।

संपादित करें: यदि आपको कुछ काम करने की आवश्यकता है जो size पर सही है, तो आपको उस पूरे कार्य को म्यूटेक्स से लपेटने की आवश्यकता होगी।

Answer 3

वाष्पशील एक कीवर्ड के लिए आप संकलक सचमुच वास्तव में लिख सकते हैं या चर पढ़ने के लिए बताने के लिए और किसी भी अनुकूलन लागू करने के लिए नहीं का उपयोग करें। यहां एक उदाहरण है

int example_function() { 
int a; 
volatile int b; 
a = 1; // this is ignored because nothing reads it before it is assigned again 
a = 2; // same here 
a = 3; // this is the last one, so a write takes place 
b = 1; // b gets written here, because b is volatile 
b = 2; // and again 
b = 3; // and again 
return a + b; 
} 

इसका वास्तविक उपयोग क्या है? मैंने इसे देरी कार्यों में देखा है (सीपीयू को एक संख्या तक गिनने के लिए व्यस्त रखें) और उन प्रणालियों में जहां कई धागे एक ही चर को देख सकते हैं। कभी-कभी यह मल्टी-थ्रेडेड चीजों के साथ एक सा मदद कर सकते हैं, लेकिन यह वास्तव में एक सूत्रण बात नहीं है और निश्चित रूप से एक चांदी की गोली नहीं है