मॉनिटर.पल्स और मॉनीटर क्या हैं। प्रतीक्षा करें?

Question

मैं समवर्ती प्रोग्रामिंग के लिए नया हूं, और मॉनिटर.पल्स और मॉनिटर.एट का उपयोग करने के लाभों को समझने की कोशिश कर रहा हूं।

class MonitorSample 
{ 
    const int MAX_LOOP_TIME = 1000; 
    Queue m_smplQueue; 

    public MonitorSample() 
    { 
     m_smplQueue = new Queue(); 
    } 
    public void FirstThread() 
    { 
     int counter = 0; 
     lock(m_smplQueue) 
     { 
      while(counter < MAX_LOOP_TIME) 
      { 
       //Wait, if the queue is busy. 
       Monitor.Wait(m_smplQueue); 
       //Push one element. 
       m_smplQueue.Enqueue(counter); 
       //Release the waiting thread. 
       Monitor.Pulse(m_smplQueue); 

       counter++; 
      } 
     } 
    } 
    public void SecondThread() 
    { 
     lock(m_smplQueue) 
     { 
      //Release the waiting thread. 
      Monitor.Pulse(m_smplQueue); 
      //Wait in the loop, while the queue is busy. 
      //Exit on the time-out when the first thread stops. 
      while(Monitor.Wait(m_smplQueue,1000)) 
      { 
       //Pop the first element. 
       int counter = (int)m_smplQueue.Dequeue(); 
       //Print the first element. 
       Console.WriteLine(counter.ToString()); 
       //Release the waiting thread. 
       Monitor.Pulse(m_smplQueue); 
      } 
     } 
    } 
    //Return the number of queue elements. 
    public int GetQueueCount() 
    { 
     return m_smplQueue.Count; 
    } 

    static void Main(string[] args) 
    { 
     //Create the MonitorSample object. 
     MonitorSample test = new MonitorSample();   
     //Create the first thread. 
     Thread tFirst = new Thread(new ThreadStart(test.FirstThread)); 
     //Create the second thread. 
     Thread tSecond = new Thread(new ThreadStart(test.SecondThread)); 
     //Start threads. 
     tFirst.Start(); 
     tSecond.Start(); 
     //wait to the end of the two threads 
     tFirst.Join(); 
     tSecond.Join();   
     //Print the number of queue elements. 
     Console.WriteLine("Queue Count = " + test.GetQueueCount().ToString()); 
    } 
} 

और मैं नहीं कर सकते प्रतीक्षा उपयोग करने का लाभ देखना और यह करने के बजाय पल्स:

MSDN के उदाहरण का पालन करना है

public void FirstThreadTwo() 
    { 
     int counter = 0; 
     while (counter < MAX_LOOP_TIME) 
     { 
      lock (m_smplQueue) 
      { 
       m_smplQueue.Enqueue(counter); 
       counter++; 
      } 
     } 
    } 
    public void SecondThreadTwo() 
    { 
     while (true) 
     { 
      lock (m_smplQueue) 
      { 
        int counter = (int)m_smplQueue.Dequeue(); 
        Console.WriteLine(counter.ToString()); 
      } 
     } 
    } 

कोई मदद सबसे की सराहना की है। धन्यवाद

Answer 1

"फायदे" का वर्णन करने के लिए, एक महत्वपूर्ण सवाल "क्या है?"। यदि आपका मतलब है "हॉट-लूप को वरीयता में", तो, सीपीयू उपयोग स्पष्ट है। यदि आपका मतलब है "नींद/पुनः प्रयास लूप की प्राथमिकता में" - आपको बहुत तेज प्रतिक्रिया मिल सकती है (Pulse को लंबे समय तक प्रतीक्षा करने की आवश्यकता नहीं है) और कम CPU का उपयोग करें (आपने 2000 बार अनावश्यक रूप से जागृत नहीं किया है)।

आम तौर पर, लोगों का मतलब है "म्यूटेक्स आदि में प्राथमिकता"।

मैं इन बड़े पैमाने पर का उपयोग करता हूं, यहां तक ​​कि म्यूटेक्स, रीसेट-इवेंट आदि की वरीयता में भी; कारण:

• वे सरल हैं, और, परिदृश्यों मैं जरूरत
• वे अपेक्षाकृत सस्ते के सबसे को कवर किया, क्योंकि वे (Mutex आदि, जो स्वामित्व के विपरीत ओएस हैंडल करने के लिए सभी रास्ते जाने की जरूरत नहीं है ओएस द्वारा)
• मैं आम तौर पर कर रहा हूँ पहले से ही तुल्यकालन को संभालने के लिए, इसलिए संभावना है अच्छा है कि मैं पहले से ही एक lock जब मैं कुछ
• यह मेरे सामान्य उद्देश्य को प्राप्त होता है के लिए प्रतीक्षा करने की आवश्यकता है lock का उपयोग कर - 2 धागे की इजाजत दी एक प्रबंधित तरीके से प्रत्येक-दूसरे को सिग्नल पूरा करना
• मैं शायद ही कभी (जैसे अंतर-प्रक्रिया होने के रूप में) अन्य Mutex आदि की सुविधाओं

Answer 2

यह मॉनिटर.पल्स/प्रतीक्षा का उपयोग करने के लिए एक प्रदर्शन सुधार है, जैसा आपने अनुमान लगाया है। यह लॉक प्राप्त करने के लिए अपेक्षाकृत महंगा ऑपरेशन है। Monitor.Wait का उपयोग करके, आपका धागा तब तक सो जाएगा जब तक कि कुछ अन्य धागे आपके मॉनिटर को 'मॉनीटर.पल्स' के साथ जगाएंगे।

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

Answer 3

आपके स्निपेट में एक गंभीर दोष है, सेकेंड थ्रेड दो() एक खाली कतार पर डेक्यू() को कॉल करने का प्रयास करते समय बुरी तरह विफल हो जाएगा। आपको संभवत: इसे पहले थ्रेड द्वारा पहले थ्रेड थ्रेड (2) उपभोक्ता थ्रेड से पहले एक सेकेंड का एक अंश निष्पादित करके काम करने के लिए मिला है। यह एक दुर्घटना है, जो कि इन धागे को थोड़ी देर के लिए चलाने या उन्हें एक अलग मशीन लोड के साथ शुरू करने के बाद काम करना बंद कर देगा। यह कभी-कभी विफलता का निदान करने के लिए बहुत मुश्किल से गलती से त्रुटि मुक्त कर सकता है।

लॉकिंग एल्गोरिदम लिखने का कोई तरीका नहीं है जो उपभोक्ता को अवरुद्ध करता है जब तक कि कतार केवल लॉक स्टेटमेंट के साथ खाली न हो जाए। एक व्यस्त लूप जो लगातार लॉक काम करता है और बाहर निकलता है लेकिन एक बहुत ही खराब विकल्प है।

इस प्रकार का कोड थ्रेडिंग गुरुओं के लिए सबसे अच्छा छोड़ दिया गया है, यह साबित करना बहुत मुश्किल है कि यह सभी मामलों में काम करता है। इस या थ्रेडिंग दौड़ जैसी विफलता मोड की अनुपस्थिति नहीं। लेकिन एल्गोरिदम की सामान्य फिटनेस जो डेडलॉक, लाइनलॉक और थ्रेड कफॉय से बचाती है। .NET दुनिया में, गुरु जेफरी रिक्टर और जो डफी हैं। वे नाश्ते के लिए लॉकिंग डिज़ाइन खाते हैं, दोनों अपनी किताबों और उनके ब्लॉग और पत्रिका लेखों में। उनके कोड चोरी करना अपेक्षित और स्वीकार किया जाता है। और आंशिक रूप से सिस्टम में जोड़ों के साथ .NET ढांचे में प्रवेश किया। चयन। कॉनकुरेंट नेमस्पेस।

Answer 4

Pulse के फायदे की जरूरत है और Wait कि वे mutexes, घटनाओं सहित अन्य सभी तुल्यकालन तंत्र के लिए बिल्डिंग ब्लॉक के रूप में इस्तेमाल किया जा सकता है, बाधाएं, इत्यादि ऐसी चीजें हैं जिन्हें Pulse और Wait के साथ किया जा सकता है जिसे बीसीएल में किसी अन्य सिंक्रनाइज़ेशन तंत्र के साथ नहीं किया जा सकता है।

सभी दिलचस्प चीजें Wait विधि के अंदर होती हैं। Wait महत्वपूर्ण अनुभाग से बाहर निकल जाएगा और थ्रेड को WaitSleepJoin स्थिति में प्रतीक्षा कतार में रखकर रखेगा। एक बार Pulse कहा जाता है तो प्रतीक्षा कतार में अगला धागा तैयार कतार में चला जाता है। एक बार थ्रेड Running स्थिति में स्विच हो जाने पर यह महत्वपूर्ण खंड को पुन: प्रस्तुत करता है। एक और तरीका दोहराना महत्वपूर्ण है। Wait लॉक को रिलीज़ करेगा और इसे परमाणु फैशन में पुनः प्राप्त करेगा। इस सुविधा में कोई अन्य सिंक्रनाइज़ेशन तंत्र नहीं है।

इस पर विचार करने का सबसे अच्छा तरीका किसी अन्य रणनीति के साथ व्यवहार को दोहराने का प्रयास करना है और फिर देखें कि क्या गलत हो सकता है। Set और WaitOne विधियों के समान के साथ इस excerise को आजमाएं, जैसे वे समान हो सकते हैं। हमारा पहला प्रयास इस तरह दिख सकता है।

void FirstThread() 
{ 
    lock (mre) 
    { 
    // Do stuff. 
    mre.Set(); 
    // Do stuff. 
    } 
} 

void SecondThread() 
{ 
    lock (mre) 
    { 
    // Do stuff. 
    while (!CheckSomeCondition()) 
    { 
     mre.WaitOne(); 
    } 
    // Do stuff. 
    } 
} 

यह देखना आसान होना चाहिए कि कोड डेडलॉक कर सकता है। तो अगर हम इस मूर्खतापूर्ण फिक्स को आजमाते हैं तो क्या होता है?

void FirstThread() 
{ 
    lock (mre) 
    { 
    // Do stuff. 
    mre.Set(); 
    // Do stuff. 
    } 
} 

void SecondThread() 
{ 
    lock (mre) 
    { 
    // Do stuff. 
    } 
    while (!CheckSomeCondition()) 
    { 
    mre.WaitOne(); 
    } 
    lock (mre) 
    { 
    // Do stuff. 
    } 
} 

क्या आप देख सकते हैं कि यहां क्या गलत हो सकता है? चूंकि प्रतीक्षा की स्थिति की जांच के बाद हमने लॉक को परमाणु रूप से पुन: प्रस्तुत नहीं किया था, इसलिए एक और धागा स्थिति में अमान्य हो सकता है और अमान्य हो सकता है। दूसरे शब्दों में, एक और धागा कुछ ऐसा कर सकता है जो CheckSomeCondition का कारण बनता है ताकि निम्नलिखित लॉक को पुनः प्राप्त करने से पहले false लौटाया जा सके। यदि आपके कोड के दूसरे ब्लॉक की आवश्यकता है तो यह स्थिति निश्चित रूप से बहुत अजीब समस्याओं का कारण बन सकती है कि स्थिति true हो।