क्यों एक स्थानीय चर सी # में अस्थिर नहीं किया जा सकता?

Question

public void MyTest() 
{ 
    bool eventFinished = false; 

    myEventRaiser.OnEvent += delegate { doStuff(); eventFinished = true; }; 
    myEventRaiser.RaiseEventInSeperateThread() 

    while(!eventFinished) Thread.Sleep(1); 

    Assert.That(stuff); 
} 

क्यों अस्थिर हो eventFinished नहीं कर सकते हैं और यह फर्क पड़ता है?

यह मेरे लिए प्रतीत होता है कि इस मामले में संकलक या क्रम अपने अच्छे के लिए स्मार्ट करने के लिए हो सकता है और जब तक पाश कि eventFinished केवल झूठे हो सकता है में 'पता' कहते हैं। खासकर जब आप जिस तरह से विचार करना एक को उठा लिया चर एक वर्ग के एक सदस्य और कहा कि एक ही कक्षा के एक तरीके के रूप में प्रतिनिधि और तथ्य यह है कि एक बार eventFinished एक स्थानीय चर था की जिससे वंचित अनुकूलन के रूप में उत्पन्न हो जाता है।

Answer 1

एक सूत्रण आदिम, ManualResetEvent ठीक इस कार्य को करने के लिए मौजूद है - आप एक बूलियन ध्वज का उपयोग करने के लिए नहीं करना चाहती।

कुछ इस तरह काम करना चाहिए:

public void MyTest() 
{ 
    var doneEvent = new ManualResetEvent(false); 

    myEventRaiser.OnEvent += delegate { doStuff(); doneEvent.Set(); }; 
    myEventRaiser.RaiseEventInSeparateThread(); 
    doneEvent.WaitOne(); 

    Assert.That(stuff); 
} 

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

Answer 2

अगर घटना उठाया जब तक के बाद प्रक्रिया है कि स्थानीय चर का दायरा से बाहर निकल गया था पूरी नहीं हुई तो क्या होगा? चर जारी किया गया होगा और आपका धागा असफल हो जाएगा।

समझदार दृष्टिकोण एक प्रतिनिधि समारोह को संलग्न करना है जो उप-धागे को पूरा करने वाले पैरेंट थ्रेड को इंगित करता है।

Answer 3

में परिदृश्य, स्थानीय चर धागे के लिए विशिष्ट हैं, इसलिए volatile से जुड़े मुद्दे पूरी तरह से अनावश्यक हैं।

यह तब होता है जब आपके उदाहरण में, यह एक "कब्जा" चर होता है - जब इसे एक कंपाइलर से उत्पन्न वर्ग पर चुपचाप लागू किया जाता है। तो सिद्धांत में यह अस्थिर हो सकता है, लेकिन ज्यादातर मामलों में यह अतिरिक्त जटिलता के लायक नहीं होगा।

विशेष रूप से Monitor (उर्फ lock) जैसे Pulse आदि के साथ कुछ ऐसा ही कर सकता है, जैसा कि अन्य थ्रेडिंग संरचनाओं की संख्या हो सकती है।

थ्रेडिंग मुश्किल है, और एक सक्रिय पाश शायद ही कभी यह प्रबंधन करने के लिए सबसे अच्छा तरीका है ...

---

पुन संपादित करें ... secondThread.Join() स्पष्ट बात हो सकता है - लेकिन तुम सच में उपयोग करना चाहते हैं एक अलग टोकन, नीचे देखें। इसका लाभ (ManualResetEvent जैसी चीजों पर) यह है कि इसे ओएस से कुछ भी आवश्यकता नहीं है - इसे पूरी तरह से सीएलआई के अंदर संभाला जाता है।

using System; 
using System.Threading; 
static class Program { 
    static void WriteLine(string message) { 
     Console.WriteLine(Thread.CurrentThread.Name + ": " + message); 
    } 
    static void Main() { 
     Thread.CurrentThread.Name = "Main"; 
     object syncLock = new object(); 
     Thread thread = new Thread(DoStuff); 
     thread.Name = "DoStuff"; 
     lock (syncLock) { 
      WriteLine("starting second thread"); 
      thread.Start(syncLock); 
      Monitor.Wait(syncLock); 
     } 
     WriteLine("exiting"); 
    } 
    static void DoStuff(object lockHandle) { 
     WriteLine("entered"); 

     for (int i = 0; i < 10; i++) { 
      Thread.Sleep(500); 
      WriteLine("working..."); 
     } 
     lock (lockHandle) { 
      Monitor.Pulse(lockHandle); 
     } 
     WriteLine("exiting"); 
    } 
} 

Answer 4

यदि आप स्थानीय var को अस्थिर के रूप में व्यवहार करना चाहते हैं तो आप Voltile.Write का भी उपयोग कर सकते हैं। जैसा कि:

public void MyTest() 
{ 
    bool eventFinished = false; 

    myEventRaiser.OnEvent += delegate { doStuff(); Volatile.Write(ref eventFinished, true); }; 
    myEventRaiser.RaiseEventInSeperateThread() 

    while(!Volatile.Read(eventFinished)) Thread.Sleep(1); 

    Assert.That(stuff); 
}