सी #

Question

में कंडीशन वेरिएबल & मॉनीटर सी # में उपयोग किए गए हैं?

क्या कोई मुझे एक उदाहरण दे सकता है?

Answer 1

है कि आप नेट में संकेतन के लिए बस का उपयोग एक शर्त चर के बराबर सार WaitHandle वर्ग है। इसके व्यावहारिक कार्यान्वयन मैनुअल रीसेट इवेंट और ऑटोरसेटवेन्ट कक्षाएं हैं।

एक शर्त चर जो आप मॉनीटर के रूप में उपयोग करते हैं सिस्टम की आवश्यकता होती है। थ्रेडिंग। मॉनिटर। सी # lock कथन का उपयोग करना बहुत आसान बनाता है, यह सुनिश्चित करता है कि मॉनिटर हमेशा बाहर निकलने() कॉल को प्रोग्राम किए बिना बाहर निकलता है।

Answer 2

आप लॉक ऑब्जेक्ट का उपयोग कर सकते हैं जो मॉनिटर क्लास के लिए सिंटैक्टिक चीनी के रूप में कार्य करता है।

lock(someObject) 
{ 
    // Thread safe code here. 
} 

http://msdn.microsoft.com/en-us/library/c5kehkcz%28VS.80%29.aspx

Answer 3

System.Threading.Monitor एक ही रास्ता (भीतर उदाहरण)

Answer 4

मैनुअल रीसेट और दोस्तों के विकल्प के रूप में, विंडोज अब स्थिति चर के लिए native support प्रदान करता है। मैंने इसे स्वयं बेंचमार्क नहीं किया है, लेकिन देशी एपीआई का लाभ उठाने पर आपका प्रदर्शन बेहतर होगा।

यहाँ एक कोड परियोजना लेख कैसे इस (अपेक्षाकृत नया) तक पहुँचने के लिए सी # से निर्माण बताते हैं कि बताया गया है:

A .NET Wrapper for the Vista/Server 2008 Condition Variable

Answer 5

इस संस्करण atomically एक Mutex या ReaderWriterLockSlim जबकि संकेत के लिए इंतज़ार कर बातें बताता है, और लौटने से पहले यह पुन: लॉक - जो पॉज़िक्स तरीका है।

using System.Collections.Concurrent; 

namespace System.Threading.More { 
    public class ConditionVariable { 
     private readonly ConcurrentQueue<ManualResetEventSlim> _waitingThreads = new ConcurrentQueue<ManualResetEventSlim>(); 

     /// <summary> 
     ///  Atomically unlocks and waits for a signal. 
     ///  Then relocks the mutex before returning 
     /// </summary> 
     /// <param name="mutex"></param> 
     public void Wait(Mutex mutex) { 
      if (mutex == null) { 
       throw new ArgumentNullException("mutex"); 
      } 
      var waitHandle = new ManualResetEventSlim(); 
      try { 
       _waitingThreads.Enqueue(waitHandle); 
       mutex.ReleaseMutex(); 
       waitHandle.Wait(); 
      } finally { 
       waitHandle.Dispose(); 
      } 
      mutex.WaitOne(); 
     } 

     public void WaitRead(ReaderWriterLockSlim readerWriterLock) { 
      if (readerWriterLock == null) { 
       throw new ArgumentNullException("readerWriterLock"); 
      } 
      var waitHandle = new ManualResetEventSlim(); 
      try { 
       _waitingThreads.Enqueue(waitHandle); 
       readerWriterLock.ExitReadLock(); 
       waitHandle.Wait(); 
      } finally { 
       waitHandle.Dispose(); 
      } 
      readerWriterLock.EnterReadLock(); 
     } 

     public void Signal() { 
      ManualResetEventSlim waitHandle; 
      if (_waitingThreads.TryDequeue(out waitHandle)) { 
       waitHandle.Set(); 
      } 
     } 

     public void Broadcast() { 
      ManualResetEventSlim waitHandle; 
      while (_waitingThreads.TryDequeue(out waitHandle)) { 
       waitHandle.Set(); 
      } 
     } 
    } 
}