सी के Atomicity # वालों ऑपरेटर

Question

मैं हमारे codebase में आज कुछ सिंगलटन कोड में पड़ गए और मैं अगर निम्नलिखित धागे की सुरक्षित था यकीन नहीं था:

if (_sentence != null) { 
     return _sentence; 
} 
else { 
    return (_sentence = new Sentence()); 
} 

:

public static IContentStructure Sentence{ 
    get { 
     return _sentence ?? (_sentence = new Sentence()); 
    } 
} 

इस बयान के बराबर है

मुझे विश्वास है कि ?? सिर्फ एक कंपाइलर चाल है और परिणामस्वरूप कोड अभी भी परमाणु नहीं है। दूसरे शब्दों में, दो या अधिक धागे को एक नई वाक्य में _sentence सेट करने और इसे वापस करने से पहले शून्य होने के लिए शून्य हो सकता है। सब सही है कि है

public static IContentStructure Sentence{ 
    get { 

     lock (_sentence) { return _sentence ?? (_sentence = new Sentence()); } 
    } 
} 

:

atomicity की गारंटी के लिए, हम कोड की कि बिट लॉक करने के लिए होगा?

Answer 1

आप सही हैं; यह सब थ्रेड-सुरक्षित नहीं है।

Answer 2

Interlocked.CompareExchangenull के साथ ?? -esque ऑपरेशन जो परमाणु है, प्राप्त करने के लिए आप Interlocked.CompareExchange का उपयोग कर सकते हैं।

// I made up my own Sentence type 
Sentence current = null; 
var whenNull = new Sentence() {Text = "Hello World!"}; 

var original = Interlocked.CompareExchange(ref current, new Sentence() { Text = "Hello World!" }, null); 

Assert.AreEqual(whenNull.Text, current.Text); 
Assert.IsNull(orig); 

// try that it won't override when not null 
current.Text += "!"; 
orig = Interlocked.CompareExchange(ref current, new Sentence() { Text = "Hello World!" }, null); 

Assert.AreEqual("Hello World!!", current.Text); 
Assert.IsNotNull(orig); 

Answer 3

मैं हमारे codebase में आज कुछ सिंगलटन कोड में भाग

आप अपने codebase भर में इस तरह के अस्पष्ट कोड है? यह कोड वही काम करता है:

if (_s == null) 
    _s = new S(); 
return _s; 

और पढ़ने के लिए लगभग एक हजार बार आसान है।

मुझे विश्वास है कि ?? केवल एक कंपाइलर चाल है और परिणामस्वरूप कोड अभी भी परमाणु नहीं है

आप सही हैं। सी # atomicity के निम्नलिखित की गारंटी देता है बनाता है:

पढ़ता है और निम्न डेटा प्रकारों के बारे में लिखते परमाणु कर रहे हैं: bool, चार, बाइट, sbyte, लघु, ushort, uint, int, नाव, और संदर्भ प्रकार के। इसके अलावा, पिछली सूची में अंतर्निहित प्रकार के साथ enum प्रकारों के पढ़ने और लिखने पर भी परमाणु हैं। लंबे, उलझन, डबल, और दशमलव, साथ ही उपयोगकर्ता द्वारा परिभाषित प्रकार सहित अन्य प्रकार के पढ़ और लिखते हैं, परमाणु होने की गारंटी नहीं है। उस उद्देश्य के लिए डिज़ाइन किए गए लाइब्रेरी फ़ंक्शंस के अलावा, वृद्धि या कमी के मामले में परमाणु पढ़ने-संशोधित-लेखन की कोई गारंटी नहीं है।

शून्य coalescing ऑपरेटर गारंटी की उस सूची पर नहीं है।

atomicity की गारंटी के लिए, हम कोड की कि बिट लॉक करने के लिए होगा:

lock (_sentence) { return _sentence ?? (_sentence = new Sentence()); } } }  

अच्छा आकाश नहीं। वह तुरंत दुर्घटनाग्रस्त हो जाता है!

• बंद करो बहु कोड लिखने की कोशिश कर:

  सही बात करने के लिए में से एक है।

• एक सिंगलटन एकमात्र के बारे में अपने पेज पर सुरक्षित सिंगलटन पैटर्न जॉन स्कीट दस्तावेजों में से एक का उपयोग कर लिखें।
• Lazy<T> कक्षा का उपयोग करें।
• उस चर को लॉक करने के लिए समर्पित ऑब्जेक्ट पर लॉक करें।
• एक परमाणु परीक्षण और सेट करने के लिए एक इंटरलॉक तुलना एक्सचेंज का उपयोग करें।