परमाणु लौटा है और क्या मुझे गेट में सुरक्षित होने के लिए अस्थायी उपयोग करना चाहिए?

Question

क्या थ्रेड-सुरक्षित होने के लिए यहां अस्थायी उपयोग करना आवश्यक है?

int getVal() { 
     this->_mutex.lock(); 
     int result = this->_val; 
     this->_mutex.unlock(); 
     return result; 
} 

मैं तुम्हें सरल आरए II परीक्षण समारोह के disassembly दे देंगे

int test() 
{ 
    RAIITest raii; //let's say it's a scoped lock 
    return 3; 
} 


{ 
    0x004013ce <_Z4testv>: push %ebp 
    0x004013cf <_Z4testv+1>: mov %esp,%ebp 
    0x004013d1 <_Z4testv+3>: sub $0x28,%esp 
    return 3; 
    0x004013d4 <_Z4testv+6>: lea -0x18(%ebp),%eax 
    0x004013d7 <_Z4testv+9>: mov %eax,(%esp) 
    0x004013da <_Z4testv+12>: call 0x4167a0 <_ZN8RAIITestD1Ev> //here destructor is called 
    0x004013df <_Z4testv+17>: mov $0x3,%eax //here result is pushed onto the stack 
} 
0x004013e4 <_Z4testv+22>: leave 
0x004013e5 <_Z4testv+23>: ret 

संकलक है जीसीसी/जी ++ 3.4.5

Answer 1

this->_val के लिए उपयोग this->_mutex द्वारा सिंक्रनाइज़ है, तो आप डॉन वर्तमान में कोड लिखा गया तरीका पसंद नहीं है। म्यूटएक्स को अनलॉक करने से पहले आपको this->_val पढ़ने की आवश्यकता है और आपको वापस आने से पहले म्यूटेक्स को अनलॉक करना होगा। क्रियाओं के इस आदेश को प्राप्त करने के लिए result चर आवश्यक है।

आप उपयोग करते हैं एक lock_guard (या scoped_lock बूस्ट में), तो आप अस्थायी उपयोग करने के लिए क्योंकि म्युटेक्स पर ताला जब समारोह रिटर्न जारी किया जाएगा जरूरत नहीं है। उदाहरण के लिए, का उपयोग करते हुए C++ 0x धागे पुस्तकालय:

int getVal() { 
    std::lock_guard<std::mutex> lock(_mutex); 
    return this->_val; 
} // lock is released by lock_guard destructor 

Answer 2

हाँ अगर आप स्पष्ट लॉक का उपयोग()/अनलॉक()। नहीं, यदि आप स्टैक पर लॉक ऑब्जेक्ट बनाते हैं और इसके विनाशक अनलॉक करते हैं।

Answer 3

नहीं - संकलक स्वचालित रूप से वापसी मूल्य के लिए अस्थायी बनाता है। आपको आमतौर पर म्यूटेक्स के साथ पढ़ने की आवश्यकता नहीं होती है, भले ही इसके बहुप्रचारित, return _val; पर्याप्त होना चाहिए।

एक तरफ, मैं अग्रणी अंडरस्कोर से छुटकारा पाउंगा - नियमों के बारे में नियम जो आप अंडरस्कोर से शुरू करते समय उपयोग कर सकते हैं और उपयोग नहीं कर सकते हैं, पर्याप्त जटिल हैं कि केवल उनसे बचने के लिए बेहतर है।

Answer 4

आप ऐसा कर सकते हैं सफाई से अपने म्युटेक्स एक scoped_lock कि विनाश पर बातें बताता में समझाया जाता है:

int getVal() { 
     scoped_lock lockit(_mutex); 
     return _val; 
} 

और हाँ, आप जब तक यह लौटाई गई ताला पकड़ की जरूरत है।