मॉनिटर.एट - जबकि या अगर?

Question

वर्तमान में, मैं एक बहुप्रचार परीक्षा के लिए सीख रहा हूं। मैंने the good threading article of albahari पढ़ा। मुझे मॉनिटर उपयोग पर एक प्रश्न है - यहां एक लूप का उपयोग क्यों किया जाता है यदि?

lock (_locker) 
{ 
    while (!_go) //why while and not if? 
    Monitor.Wait (_locker); // _lock is released 
    // lock is regained 
    ... 
} 

मुझे लगता है कि अगर पर्याप्त होगा।

मुझे डर है, कि मैं पूरी तरह से लेख को समझ नहीं पा रहा हूं।

// संपादित उदाहरण-कोड:

class SimpleWaitPulse 
{ 
    static readonly object _locker = new object(); 
    static bool _go; 

    static void Main() 
    {        // The new thread will block 
    new Thread (Work).Start();  // because _go==false. 

    Console.ReadLine();   // Wait for user to hit Enter 

    lock (_locker)     // Let's now wake up the thread by 
    {        // setting _go=true and pulsing. 
     _go = true; 
     Monitor.Pulse (_locker); 
    } 
    } 

    static void Work() 
    { 
    lock (_locker) 
     while (!_go) 
     Monitor.Wait (_locker); // Lock is released while we’re waiting 

    Console.WriteLine ("Woken!!!"); 
    } 
} 

Answer 1

यह सिर्फ स्थिति पर निर्भर करता है। इस मामले में कोड _goसच होने के लिए बस प्रतीक्षा कर रहा है।

हर बार _locker यह देखने के लिए कि _goसच करने के लिए सेट कर दिया गया है की जाँच करेगा स्पंदित है। यदि _go अभी भी झूठा है, तो यह अगली पल्स की प्रतीक्षा करेगा।

तो एक अगर के बजाय इस्तेमाल किया गया था एक जबकि, यह केवल एक बार (या बिल्कुल नहीं करता है, तो पहले से ही _goसच था) इंतजार करेंगे, और फिर एक नाड़ी के बाद पर जारी रहेगा, नए की परवाह किए बिना _go की स्थिति।

तो आप मॉनिटर.एट() का उपयोग कैसे करते हैं, पूरी तरह से आपकी विशिष्ट आवश्यकताओं पर निर्भर करता है।

Answer 2

यह वास्तव में स्थिति पर निर्भर करता है। लेकिन सबसे पहले, हमें यह स्पष्ट करने की आवश्यकता है कि मॉनीटर कैसे काम करते हैं। जब कोई थ्रेड मॉनिटर के माध्यम से थ्रेड को सिग्नल करने के लिए आगे बढ़ता है। पल्स(), आमतौर पर कोई गारंटी नहीं है कि सिग्नल किए गए थ्रेड वास्तव में आगे चलेंगे। इसका मतलब यह है कि सिग्नल किए गए थ्रेड से पहले अन्य धागे चलाने के लिए यह संभव है और उस स्थिति को बदलें जिसके तहत सिग्नल किए गए थ्रेड के लिए आगे बढ़ना ठीक था। इसका मतलब है कि संकेतित धागे को अभी भी जांचना होगा कि जागने के बाद आगे बढ़ना सुरक्षित है (यानी जबकि लूप)। हालांकि, कुछ दुर्लभ सिंक्रनाइज़ेशन समस्याएं आपको यह धारणा करने की अनुमति देती हैं कि एक बार थ्रेड को जागृत करने के लिए संकेत दिया गया है (यानि मॉनिटर.पल्स()), किसी अन्य थ्रेड में ऐसी स्थिति को बदलने की क्षमता नहीं है जिसके अंतर्गत यह आगे बढ़ना सुरक्षित है (यानी अगर शर्त है)। Wait and Pulse demystified

वहाँ अधिक हो रहा से तुरंत स्पष्ट है:

Answer 3

मैं एक लेख है कि यहाँ मदद कर सकता है लिखा था।

Answer 4

मुझे मॉनीटर उपयोग पर एक प्रश्न है - यहां में एक लूप का उपयोग क्यों किया जाता है?

वहाँ एक अच्छी तरह से ज्ञात नियम जब Pulse और Wait कहा गया है कि जब संदेह में एक if से अधिक while पसंद करते हैं कि साथ काम कर रहा है। जाहिर है, कोई भी इस मामले में काम करेगा, लेकिन लगभग हर दूसरी स्थिति में while आवश्यक है। वास्तव में, बहुत कम (यदि कोई हैं) परिदृश्य हैं जहां while लूप का उपयोग गलत परिणाम देगा। यह सामान्य नियम के लिए आधार है। लेखक ने while लूप का उपयोग किया क्योंकि वह कोशिश-और-सही पैटर्न से चिपकने का प्रयास कर रहा था। वह एक ही लेख में टेम्पलेट भी प्रदान करता है।यहाँ है यह है:

lock (_locker) 
    while (<blocking-condition>) 
    Monitor.Wait (_locker); 

Answer 5

सबसे आसान तरीका Monitor.Wait साथ सही कोड लिखने के लिए मान प्रणाली के रूप में "सलाहकार" यह मानेंगे, और लगता है कि प्रणाली मनमाने ढंग से किसी भी इंतज़ार कर रहे किसी भी समय थ्रेड यह प्राप्त कर सकते हैं जगा सकता है करने के लिए है ताला, चाहे Pulse कहा गया हो। सिस्टम आमतौर पर ऐसा नहीं करेगा, लेकिन यदि कोई प्रोग्राम Wait और Pulse का उपयोग कर रहा है, तो इसकी शुद्धता Wait कॉल से मनमाने ढंग से किसी भी कारण से बाहर निकलने से प्रभावित नहीं होनी चाहिए। अनिवार्य रूप से, किसी को सिस्टम को बताने के साधन के रूप में Wait पर ध्यान देना चाहिए "यहां पर निरंतर निष्पादन समय की बर्बादी होगी जब तक कि किसी और को Pulse पर कॉल न किया जाए"।