क्या यह सिग्नल करने के लिए सुरक्षित है और मैन्युअल रीसेट Event बंद करें?

Question

मुझे लगता है कि मुझे इसका जवाब पता होना चाहिए, लेकिन अगर मैं संभावित रूप से आपदाजनक गलती कर रहा हूं तो मैं वैसे भी पूछने जा रहा हूं।

निम्नलिखित कोड निष्पादित करता है कोई त्रुटि/अपवादों के साथ के रूप में उम्मीद:

static void Main(string[] args) 
{ 
    ManualResetEvent flag = new ManualResetEvent(false); 
    ThreadPool.QueueUserWorkItem(s => 
    { 
     flag.WaitOne(); 
     Console.WriteLine("Work Item 1 Executed"); 
    }); 
    ThreadPool.QueueUserWorkItem(s => 
    { 
     flag.WaitOne(); 
     Console.WriteLine("Work Item 2 Executed"); 
    }); 
    Thread.Sleep(1000); 
    flag.Set(); 
    flag.Close(); 
    Console.WriteLine("Finished"); 
} 

बेशक

, के रूप में आम तौर पर मल्टी-थ्रेडेड कोड के साथ मामला है, एक सफल परीक्षण साबित नहीं होता कि यह वास्तव में सुरक्षित थ्रेड है। अगर मैं CloseSet से पहले Close डालता हूं, तो परीक्षण भी सफल होता है, भले ही दस्तावेज़ स्पष्ट रूप से बताता है कि Close के बाद कुछ भी करने का प्रयास करने से अपरिभाषित व्यवहार होगा।

मेरा प्रश्न है, जब मैं ManualResetEvent.Set विधि आह्वान, यह सभी इंतजार कर धागे फोन करने वाले के लिए नियंत्रण लौटने से पहले संकेत करने के लिए गारंटी है? दूसरे शब्दों में, यह मानते हुए कि मैं गारंटी दे सकता हूं कि WaitOne पर कोई और कॉल नहीं होगी, क्या यह यहां हैंडल को बंद करना सुरक्षित है, या यह संभव है कि कुछ परिस्थितियों में यह कोड कुछ वेटर्स को संकेत या परिणाम प्राप्त करने से रोक देगा ObjectDisposedException में?

प्रलेखन केवल कहते हैं Set में एक "राज्य का संकेत" कहते हैं कि - इसके बारे में जब वेटर वास्तव में कि संकेत मिल जाएगा कोई दावा नहीं लगता है, तो मैं सुनिश्चित हो करना चाहते हैं।

Answer 1

जब आप ManualResetEvent.Set के साथ संकेत करते हैं तो आपको गारंटी है कि उस घटना के लिए इंतजार कर रहे सभी थ्रेड (यानी flag.WaitOne पर अवरुद्ध स्थिति में) कॉलर पर नियंत्रण लौटने से पहले संकेत दिया जाएगा।

बेशक वहाँ हालात हैं जब आप ध्वज सेट कर सकते हैं कर रहे हैं और क्योंकि यह कुछ काम कर रहा है अपने धागा नहीं देखा है इससे पहले कि यह ध्वज की जाँच करता है (या nobugs सुझाव के रूप में यदि आप एक से अधिक थ्रेड बना रहे हैं):

ThreadPool.QueueUserWorkItem(s => 
{ 
    QueryDB(); 
    flag.WaitOne(); 
    Console.WriteLine("Work Item 1 Executed"); 
}); 

ध्वज पर विवाद है और अब आप इसे बंद करते समय अपरिभाषित व्यवहार बना सकते हैं। आपका ध्वज आपके धागे के बीच एक साझा संसाधन है, आपको एक उलटी गिनती लांच बनाना चाहिए जिस पर प्रत्येक धागा पूरा होने पर संकेत करता है। यह आपके flag पर विवाद को खत्म कर देगा।

public class CountdownLatch 
{ 
    private int m_remain; 
    private EventWaitHandle m_event; 

    public CountdownLatch(int count) 
    { 
     Reset(count); 
    } 

    public void Reset(int count) 
    { 
     if (count < 0) 
      throw new ArgumentOutOfRangeException(); 
     m_remain = count; 
     m_event = new ManualResetEvent(false); 
     if (m_remain == 0) 
     { 
      m_event.Set(); 
     } 
    } 

    public void Signal() 
    { 
     // The last thread to signal also sets the event. 
     if (Interlocked.Decrement(ref m_remain) == 0) 
      m_event.Set(); 
    } 

    public void Wait() 
    { 
     m_event.WaitOne(); 
    } 
} 

1. उलटी गिनती कुंडी पर प्रत्येक धागा संकेत है।
2. आपका मुख्य धागा उलटी गिनती पर इंतजार कर रहा है।
3. मुख्य धागा उलटी गिनती के संकेतों के बाद साफ हो जाता है।

आखिरकार जब आप अंत में सोते हैं तो आपकी समस्याओं का ख्याल रखने का एक सुरक्षित तरीका नहीं है, बल्कि आपको अपने प्रोग्राम को डिज़ाइन करना चाहिए ताकि यह एक बहुप्रचारित वातावरण में 100% सुरक्षित हो।

अद्यतन: एकल निर्माता/एकाधिक उपभोक्ताओं
अनुमान यहाँ निर्माता जानता है कि कितने उपभोक्ताओं को बनाया जाएगा आप अपने सभी उपभोक्ताओं को बनाने के बाद, उपभोक्ताओं की दी गई संख्या के साथ CountdownLatch रीसेट है:

// In the Producer 
ManualResetEvent flag = new ManualResetEvent(false); 
CountdownLatch countdown = new CountdownLatch(0); 
int numConsumers = 0; 
while(hasMoreWork) 
{ 
    Consumer consumer = new Consumer(coutndown, flag); 
    // Create a new thread with each consumer 
    numConsumers++; 
} 
countdown.Reset(numConsumers); 
flag.Set(); 
countdown.Wait();// your producer waits for all of the consumers to finish 
flag.Close();// cleanup 

Answer 2

यह ठीक नहीं है। आप यहां भाग्यशाली हो रहे हैं क्योंकि आपने केवल दो धागे शुरू किए हैं। जब आप दोहरी कोर मशीन पर सेट करते हैं तो वे तुरंत चलना शुरू कर देंगे। इस के बजाय का प्रयास करें और यह बम घड़ी:

static void Main(string[] args) { 
     ManualResetEvent flag = new ManualResetEvent(false); 
     for (int ix = 0; ix < 10; ++ix) { 
      ThreadPool.QueueUserWorkItem(s => { 
       flag.WaitOne(); 
       Console.WriteLine("Work Item Executed"); 
      }); 
     } 
     Thread.Sleep(1000); 
     flag.Set(); 
     flag.Close(); 
     Console.WriteLine("Finished"); 
     Console.ReadLine(); 
    } 

आपका मूल कोड एक पुरानी मशीन या अपने वर्तमान मशीन पर इसी तरह विफल हो जाएगा जब यह अन्य कार्यों के साथ बहुत व्यस्त है।

Answer 3

मेरा लेना यह है कि दौड़ की स्थिति है। लिखित ईवेंट की शर्त चर के आधार पर वस्तुओं के बाद, आप इस तरह कोड प्राप्त:

mutex.lock(); 
while (!signalled) 
    condition_variable.wait(mutex); 
mutex.unlock(); 

इसलिए जब घटना का संकेत हो सकता है, कोड घटना पर इंतजार अभी भी घटना के कुछ हिस्सों तक पहुंच की आवश्यकता हो सकती है।

Close पर प्रलेखन के अनुसार, यह केवल अप्रबंधित संसाधनों को रिलीज़ करता है। इसलिए यदि ईवेंट केवल प्रबंधित संसाधनों का उपयोग करता है, तो आप भाग्यशाली हो सकते हैं। लेकिन भविष्य में यह बदल सकता है, इसलिए मैं सावधानी के पक्ष में गलती करूंगा और घटना को बंद नहीं करूँगा जबतक कि आपको पता न हो कि अब इसका उपयोग नहीं किया जा रहा है।

Answer 4

मेरे लिए एक जोखिम भरा पैटर्न जैसा दिखता है, भले ही [वर्तमान] कार्यान्वयन के कारण, यह ठीक है। आप एक संसाधन का निपटान करने की कोशिश कर रहे हैं जो अभी भी उपयोग में हो सकता है।

यह ऑब्जेक्ट के उपभोक्ताओं के समक्ष होने से पहले भी एक वस्तु बनाने और निर्माण करने की तरह है और इसे अंधा कर रहा है।

अन्यथा यहां problem भी है। कार्यक्रम से बाहर निकल सकता है, इससे पहले कि अन्य धागे को कभी भी चलाने का मौका मिले। थ्रेड पूल धागे पृष्ठभूमि धागे हैं।

यह देखते हुए कि आपको अन्य धागे के लिए इंतजार करना है, फिर भी आप बाद में साफ कर सकते हैं।