क्या सी # और जावा का अस्थिर कीवर्ड दोनों ही व्यवहार करते हैं?

Question

मुझे जावा में पता है, अगर आपके पास एक चर का उपयोग करने वाले एकाधिक थ्रेड हैं जो अस्थिर के रूप में चिह्नित नहीं हैं, तो आप कुछ अप्रत्याशित व्यवहार प्राप्त कर सकते हैं।

उदाहरण:

private boolean bExit; 

while(!bExit) { 
    checkUserPosition(); 
    updateUserPosition(); 
} 

आप voilatile रूप bExit चर चिह्नित करते हैं, कि गारंटी है कि अन्य थ्रेड सबसे हाल ही में मूल्य देखेंगे।

क्या सी # वही व्यवहार करता है?

int counter = ...; 

for(...) 
{ 
    new Thread(delegate() 
    { 

     Interlocked.Decrement(ref counter); 
    } 
} 


if(counter == 0) 
{ 
    // halt program 
} 

ऊपर में सी # में, आप अस्थिर रूप में काउंटर चर को चिह्नित करने की क्या ज़रूरत है या यह काम करेगा:

अद्यतन

उदाहरण के लिए, सी # में आप ऐसा करते हैं, तो जैसा सोचा था?

Answer 1

आप voilatile रूप bExit चर, कि गारंटी है कि अन्य थ्रेड सबसे हाल ही में मूल्य देखेंगे चिह्नित करते हैं। क्या सी # वही व्यवहार करता है?

---

हाँ, पर सब कैसे आप साझा चर का उपयोग पर निर्भर हैं। उदाहरण के तौर पर, यदि आप Interlocked.Decrement जैसे थ्रेड सुरक्षित तरीके में विविधता तक पहुंचते हैं तो यह voilatile का उपयोग किए बिना भी कोई मुद्दा नहीं होगा।

volatile (C# Reference from MSDN)

अस्थिर कीवर्ड इंगित करता है कि एक क्षेत्र से अधिक थ्रेड कि एक ही समय में क्रियान्वित कर रहे हैं द्वारा संशोधित किया जा सकता है। फ़ील्ड जो घोषित अस्थिर संकलक अनुकूलन के अधीन नहीं हैं एक थ्रेड द्वारा पहुंच मानें। यह सुनिश्चित करता है कि पर सबसे अधिक अप-टू-डेट मान फ़ील्ड में मौजूद है।

What is the "volatile" keyword used for?

Answer 2

आप के रूप में आप अपने उदाहरण में दो अलग अलग प्रकार चुन लिया है यहाँ एक सा सावधान रहने की जरूरत है। अंगूठे का मेरा सामान्य नियम यह है कि अस्थिर सबसे अच्छा बूलियन के साथ प्रयोग किया जाता है और बाकी सब कुछ के साथ आपको शायद किसी अन्य प्रकार की सिंकिंग तंत्र की आवश्यकता होती है। सी # और जावा में एक अस्थिर बुलियन का उपयोग करने के लिए यह बहुत आम है उदा। एक पाश या कार्य को क्रियान्वित जो एक से अधिक थ्रेड से दृश्यता है रोक:

class Processor 
{ 
    private volatile Boolean _stopProcessing = false; 

    public void process() 
    { 
     do 
     { ... } 
     while (!_stopProcessing); 
    } 

    public void cancel() 
    { 
     _stopProcessing = true; 
    } 
} 

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

तो उत्तर आपके पहले प्रश्न के लिए हाँ है।

जबकि आप किसी इंट पर अस्थिरता का उपयोग कर सकते हैं, यह केवल तभी मदद करता है जब आप केवल पढ़ रहे हों, या एक ही मूल्य लिख रहे हों। जैसे ही आप कुछ और जटिल करते हैं, उदा।बढ़ते हुए, आपको किसी अन्य प्रकार की सिंकिंग की आवश्यकता है जैसे इंटरलॉक का उपयोग। आपके दूसरे उदाहरण में हालांकि आप अभी भी बिना किसी सिंकिंग के काउंटर का मूल्य पढ़ रहे हैं, इसलिए आप प्रभावी रूप से सिंक किए जाने वाले काउंटर के अन्य उपयोगों पर निर्भर हैं (उदा। इंटरलॉक के साथ)।

अपने दूसरे उदाहरण में आप अभी भी अपने int को अस्थिर के रूप में चिह्नित करने से बेहतर होंगे, इस तरह आप फिर से सुनिश्चित कर सकते हैं कि आपको वर्तमान मूल्य मिल रहा है और कुछ कैश संस्करण नहीं हैं। हालांकि अकेले अस्थिरता का उपयोग पर्याप्त नहीं है क्योंकि नीचे की पढ़ाई इंटरलॉक के आपके सही उपयोग के बजाय मानक कमी (काउंटर--) के साथ ओवरलैप हो सकती है।