सरल म्यूटेक्स कभी। क्या यह उदाहरण काम करता है? क्या यह धागा सुरक्षित है?

Question

मैं बहु-थ्रेडिंग के लिए सबसे सरल म्यूटेक्स दृष्टिकोण के बारे में पूछना चाहता हूं। क्या निम्न कोड थ्रेड-सुरक्षित (त्वरित-एन-गंदा) है?

class myclass 
{ 
    bool locked; 
    vector<double> vals; 

    myclass(); 
    void add(double val); 
}; 

void myclass::add(double val) 
{ 
    if(!locked) 
    { 
     this->locked = 1; 
     this->vals.push_back(val); 
     this->locked = 0; 
    } 
    else 
    { 
     this->add(val); 
    } 
} 

int main() 
{ 
    myclass cls; 
    //start parallelism 
    cls.add(static_cast<double>(rand())); 
} 

क्या यह काम करता है? क्या यह धागा सुरक्षित है? मैं बस यह समझने की कोशिश कर रहा हूं कि सबसे सरल म्यूटेक्स कैसे लिखा जा सकता है।

यदि आपके पास मेरे उदाहरण के बारे में कोई सलाह है, तो अच्छा होगा।

धन्यवाद।

यह कहने के लिए धन्यवाद कि यह काम नहीं करता है। क्या आप कृपया एक फिक्स का सुझाव दे सकते हैं जो संकलक स्वतंत्र है?

Answer 1

क्या यह धागा-सुरक्षित है?

निश्चित रूप से नहीं। यदि लॉक को जांचने और सेट करने के बीच थ्रेड को प्राथमिकता दी जाती है, तो दूसरा थ्रेड उस लॉक को प्राप्त कर सकता है; यदि नियंत्रण पहले धागे पर लौटता है, तो दोनों इसे हासिल करेंगे। (और निश्चित रूप से, एक आधुनिक प्रोसेसर पर, दो या दो से अधिक कोर एक ही निर्देशों को एक साथ अधिक क्रियात्मकता के लिए निष्पादित कर सकते हैं।)

कम से कम, आपको लॉक को लागू करने के लिए परमाणु परीक्षण-और-सेट ऑपरेशन की आवश्यकता है इस तरह।

std::atomic_flag locked; 

if (!locked.test_and_set()) { 
    vals.push_back(val); 
    locked.clear(); 
} else { 
    // I don't know exactly what to do here; 
    // but recursively calling add() is a very bad idea. 
} 

या बेहतर अभी तक: सी ++ 11 लाइब्रेरी में ऐसी कोई बात प्रदान करता है

std::mutex mutex; 

std::lock_guard<std::mutex> lock(mutex); 
vals.push_back(val); 

यदि आप किसी पुराने कार्यान्वयन है, तो आप जो कुछ भी एक्सटेंशन पर भरोसा करना होगा/पुस्तकालयों में उपलब्ध हैं आपके लिए, क्योंकि भाषा या मानक पुस्तकालय में तब कुछ भी उपयोगी नहीं था।

Answer 2

क्या यह काम करता है? क्या यह धागा सुरक्षित है?

नहीं। यह कई बार विफल हो जाएगा।

आपका म्युटेक्स केवल काम करेंगे अन्य थ्रेड इन दो पंक्तियों के निष्पादन के बीच कुछ भी कभी नहीं यदि:

if(!locked) 
{ 
    this->locked = 1; 

... और आप देखेंगे कि यह सुनिश्चित किया नहीं किया है।

के बारे में जानने के लिए mutex लेखन के, this SO post देखें।

Answer 3

नहीं, यह धागा सुरक्षित नहीं है।

myclass::add चल रहे दो धागे पर विचार करें, एक ही समय में कम या कम। साथ ही, कल्पना करें कि .locked का मान false है।

पहले धागा और इस लाइन सहित अप करने के लिए निष्पादित करता है:

if(!locked) 
{ 

अब कल्पना करें कि सिस्टम दूसरा धागा करने के लिए संदर्भ स्विच करता है। यह एक ही पंक्ति तक निष्पादित करता है।

अब हमारे पास दो अलग-अलग धागे हैं, दोनों का मानना ​​है कि उनके पास विशेष पहुंच है, और दोनों !locked की स्थिति में हैं।

वे दोनों vals.push_back() को एक ही समय में कम या कम से कम कॉल करेंगे।

बूम।

Answer 4

नहीं, यह धागा सुरक्षित नहीं है। वहाँ

if(!locked) 

और

this->locked = 1; 

यदि इन दो बयानों के बीच एक संदर्भ स्विच है के बीच एक दौड़ है, अपने लॉक तंत्र के अलावा गिर जाता है। आपको एक परमाणु test and set निर्देश की आवश्यकता है, या बस मौजूदा mutex का उपयोग करें।

Answer 5

यह कोड vals वेक्टर का परमाणु संशोधन प्रदान नहीं करता है। इस परिदृश्य पर विचार करें:

//<<< Suppose it's 0 
if(!locked) 
{ //<<< Thread 0 passes the check 
    //<<< Context Switch - and Thread 1 is also there because locked is 0 
    this->locked = 1; 
    //<<< Now it's possible for one thread to be scheduled when another one is in 
    //<<< the middle of modification of the vector 
    this->vals.push_back(val); 
    this->locked = 0; 
} 

Answer 6

दूसरों को पहले से ही पता चला है कि कैसे अपने म्युटेक्स असफल हो सकता है, तो मैं उनके अंक नहीं मिला देना होगा। मैं केवल एक ही चीज़ जोड़ूंगा: सरलतम म्यूटेक्स कार्यान्वयन आपके कोड से बहुत अधिक जटिल है।

आप जुओं से भरा हुआ किरकिरा में रुचि रखते हैं - आप Leslie Lamport's Bakery Algorithm को देखो और वहाँ से चले जाना चाहिए (या यहां तक ​​कि अगर तुम नहीं कर रहे हैं इस चीज हर सॉफ्टवेयर डेवलपर पता होना चाहिए है)।