वाष्पशील और सी # में Thread.MemoryBarrier

Question

लागू करने के लिए एक आवेदन मैं volatile चर, सैद्धांतिक रूप से इस्तेमाल किया multithreading के लिए मुफ्त कोड ताला: volatile कीवर्ड बस सुनिश्चित करें कि सभी धागे एक के सबसे अद्यतन मूल्य देख बनाने के लिए प्रयोग किया जाता है अस्थिर चर; इसलिए धागा A चर मूल्य अद्यतन करता है और धागा B पढ़ा है कि चर के तुरंत बाद कि अद्यतन हुआ है यह सबसे अद्यतन मूल्य के रूप में मैं संक्षेप किताब कि में एक सी # 4.0 में पढ़ा है कि धागा ए से हाल ही में लिखा देखेंगे अगर इस गलत क्योंकि

अस्थिर एक लिखने की अदला-बदली किए जाने से पढ़ने के बाद से नहीं रोकता है को लागू करने के लिए है।

इस समस्या volatile चर की तरह के हर से पहले Thread.MemoryBarrier() डाल द्वारा हल किया जा रहा किया जा सका:

private volatile bool _foo = false; 

private void A() 
{ 
    //… 
    Thread.MemoryBarrier(); 
    if (_foo) 
    { 
     //do somthing 
    } 
} 

private void B() 
{ 
    //… 
    _foo = true; 
    //… 
} 

और इस समस्या का हल है; मान लें कि हमारे पास थोड़ी देर लूप है जो उस मूल्य पर निर्भर करता है; जबकि लूप समस्या को ठीक करने का सही तरीका है, इससे पहले Thread.MemoryBarrier() डाल रहा है? उदाहरण:

private void A() 
{ 
    Thread.MemoryBarrier(); 
    while (_someOtherConditions && _foo) 
    { 
     // do somthing. 
    } 
} 

अधिक सटीक मैं _foo चर इसकी सबसे ताजा मूल्य जब किसी भी धागा इसे किसी भी समय के लिए पूछ देना चाहता हूँ होना करने के लिए; इसलिए Thread.MemoryBarrier() डालने से पहले चर बुला समस्या ठीक होती है तो मैं _foo के बजाय Foo संपत्ति का उपयोग करें और की है कि संपत्ति की तरह प्राप्त भीतर एक Thread.MemoryBarrier() कर सकता है यदि:

Foo 
{ 
    get 
    { 
     Thread.MemoryBarrier(); 
     return _foo; 
    } 
    set 
    { 
     _foo = value; 
    } 
} 

Answer 1

"सी # संक्षेप में" सही है, लेकिन इसका कथन मंथन है। क्यूं कर?

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

चलो स्पष्ट करें। अपने मूल कोड डालें:

private void A() 
{ 
    //… 
    if (_foo) 
    { 
     //do something 
    } 
} 

अगर धागा अनुसूचक पहले से ही _foo चर की जाँच की है, लेकिन यह सिर्फ //do something टिप्पणी से पहले निलंबित हो जाती है तो क्या होगा? खैर, उस बिंदु पर आपका अन्य धागा _foo के मान को बदल सकता है, जिसका अर्थ है कि आपके सभी अस्थिरताएं और थ्रेड। स्मृति बॉरियर्स कुछ भी नहीं गिने गए !!! यदि यह बिल्कुल जरूरी है कि do_something से बचा जाए तो _foo का मान गलत है, तो आपके पास लॉक का उपयोग करने के अलावा कोई विकल्प नहीं है।

हालांकि, अगर do something के लिए यह ठीक है तो _foo अचानक हो जाने पर निष्पादित होने के लिए ठीक है, तो इसका मतलब है कि अस्थिर कीवर्ड आपकी आवश्यकताओं के लिए पर्याप्त था।

स्पष्ट होने के लिए: सभी उत्तरदाता जो आपको स्मृति बाधा का उपयोग करने के लिए कह रहे हैं गलत हैं या ओवरकिल प्रदान कर रहे हैं।

Answer 2

अपने दूसरे उदाहरण में, आप भी डाल करने की आवश्यकता होगी लूप के अंदर Thread.MemoryBarrier();, यह सुनिश्चित करने के लिए कि जब भी आप लूप स्थिति की जांच करते हैं तो आपको सबसे हालिया मूल्य मिलता है।

Answer 3

here से खींचा ...

class Foo 
{ 
    int _answer; 
    bool _complete; 

    void A() 
    { 
    _answer = 123; 
    Thread.MemoryBarrier(); // Barrier 1 
    _complete = true; 
    Thread.MemoryBarrier(); // Barrier 2 
    } 

    void B() 
    { 
    Thread.MemoryBarrier(); // Barrier 3 
    if (_complete) 
    { 
     Thread.MemoryBarrier();  // Barrier 4 
     Console.WriteLine (_answer); 
    } 
    } 
} 

बाधाओं 1 और 4 "0" लिखने से इस उदाहरण को रोकने के। बाधाएं 2 और 3 ताजगी गारंटी प्रदान करते हैं: वे सुनिश्चित करते हैं कि यदि बी ए के बाद भाग गया, तो पढ़ना _complete सत्य का मूल्यांकन करेगा।

तो अगर हम अपने पाशन उदाहरण के लिए वापस जाओ ... यह है कि यह कैसे दिखना चाहिए है ...

private void A() 
{ 
    Thread.MemoryBarrier(); 
    while (_someOtherConditions && _foo) 
    { 
     //do somthing 
     Thread.MemoryBarrier(); 
    } 
} 

Answer 4

माइक्रोसॉफ्ट के स्मृति बाधाओं पर ही शब्दों:

MemoryBarrier केवल की आवश्यकता नहीं है कमजोर मेमोरी ऑर्डरिंग के साथ मल्टीप्रोसेसर सिस्टम (उदाहरण के लिए, एक इंटेल इटेनियम प्रोसेसर को नियोजित करने वाला एक सिस्टम)।

अधिकांश उद्देश्यों के लिए, सी # लॉक स्टेटमेंट, विजुअल बेसिक सिंकलॉक स्टेटमेंट, या मॉनिटर क्लास डेटा सिंक्रनाइज़ करने के आसान तरीके प्रदान करता है।

Answer 5

पुस्तक सही है।
सीएलआर का मेमोरी मॉडल इंगित करता है कि लोड और स्टोर ऑपरेशंस को फिर से व्यवस्थित किया जा सकता है। यह अस्थिर और गैर-अस्थिर चर के लिए जाता है।

volatile के रूप में एक चर की घोषणा केवल इसका मतलब है कि लोड आपरेशन अधिग्रहण अर्थ विज्ञान होगा, और दुकान संचालन रिहाई अर्थ विज्ञान होगा। साथ ही, संकलक कुछ अनुकूलन निष्पादित करने से बचेंगे जो इस तथ्य पर निर्भर करते हैं कि परिवर्तनीय को एक धारावाहिक, सिंगल-थ्रेडेड फ़ैशन (जैसे उछाल लोड/स्टोर्स से बाहर स्टोर) में एक्सेस किया जाता है।

volatile का उपयोग अकेले कीवर्ड महत्वपूर्ण वर्ग नहीं बनाते हैं, और इससे धागे एक दूसरे के साथ जादुई रूप से सिंक्रनाइज़ नहीं होते हैं।

आपको लॉक फ्री कोड लिखते समय अत्यंत सावधान रहना चाहिए। इसके बारे में कुछ भी आसान नहीं है, और यहां तक ​​कि विशेषज्ञों को भी इसे सही करने में परेशानी है।
जो भी मूल समस्या आप हल करने की कोशिश कर रहे हैं, यह संभावना है कि ऐसा करने का एक और अधिक उचित तरीका है।