इंतजार कैसे करता है() ताला जावा

Question

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

मेरे सवाल यह है कि प्रतीक्षा() धागा ताला वापस पाने के है?

// Thread 1 
    synchronized (mon) { 
    while (!condition) 
      mon.wait(); 

    // Do something 
    } 

//Thread 2 
    synchronized (mon) {//set condition appropriately 
      mon.notify(); 
    } 

धागे को पहले 1 रन पर विचार करें और स्थिति की प्रतीक्षा करना शुरू करें। यह लॉक जारी करता है और थ्रेड 2 लॉक को स्थिति सेट करता है और थ्रेड को सूचित करता है 1. अब थ्रेड 1 लॉक हो जाता है, स्थिति की जांच करता है और "कुछ करें" निष्पादित करना शुरू करता है।

मेरा प्रश्न यह है कि जब थ्रेड 1 अधिसूचित किया जाता है तो यह समय की स्थिति से निष्पादन शुरू करता है, सिंक्रनाइज़ (सोम) कोड की रेखा को फिर से निष्पादित नहीं किया जाता है तो थ्रेड 1 लॉक कैसे प्राप्त करता है? आंतरिक गतिशीलता क्या हैं जो लॉक को थ्रेड 1 पर वापस देती हैं?

Answer 1

जब Thread1 धागा अधिसूचित किया गया है ताला प्राप्त करने के लिए इससे पहले कि यह इंतजार विधि निकल सकते हैं, के लिए वस्तु # इंतजार जावा दस्तावेज़ नहीं देख है:

धागा T तो इस के लिए प्रतीक्षा सेट से निकाल दिया जाता है ऑब्जेक्ट और थ्रेड शेड्यूलिंग के लिए पुनः सक्षम। इसके बाद ऑब्जेक्ट पर सिंक्रनाइज़ करने के अधिकार के लिए सामान्य तरीके से अन्य धागे के साथ प्रतिस्पर्धा करता है; एक बार जब यह ऑब्जेक्ट का नियंत्रण प्राप्त कर लेता है, तो उसके सभी ऑब्जेक्ट पर सिंक्रनाइज़ेशन दावों को स्थिति एंटी स्थिति में बहाल कर दिया जाता है - यानी स्थिति के अनुसार wait विधि लागू की गई थी। थ्रेड T तो wait विधि के मंगलाचरण से वापस आती है। इस प्रकार, wait विधि से वापस लौटने पर, ऑब्जेक्ट की सिंक्रनाइज़ेशन स्थिति और थ्रेड T ठीक उसी तरह है जब wait विधि लागू हुई थी।

Answer 2

synchronized(mon) एक अभिव्यक्ति नहीं है जिसे निष्पादित किया जाना है।

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

wait() अवरोध समाप्त, और लौटने से पहले यह पुनः प्राप्त करना होगा।

Answer 3

थ्रेड 1 अधिसूचित होने के बाद, इसे तुरंत लॉक मिला और // कुछ चलाने के लिए शुरू करें।

जब थ्रेड 1 इंतजार, यह सिर्फ अस्थायी रूप से अवरोध खोल, और जब धागा अधिसूचित किया गया है, यह ताला फिर से प्राप्त कर सकते हैं और सिंक्रनाइज़ चला की जरूरत नहीं है (...)।

Answer 4

// Thread 1 
synchronized (mon) { 
Systemout.println("I am invoked!"); 
while (!condition) 
     mon.wait(); 

// Do something 
} 

//Thread 2 
synchronized (mon) {//set condition appropriately 
     mon.notify(); 
} 

मूल परिदृश्य में: पहले विचार करें धागा 1 रन और हालत के लिए इंतज़ार कर शुरू होता है। यह लॉक जारी करता है और थ्रेड 2 लॉक को स्थिति सेट करता है और थ्रेड को सूचित करता है 1. अब थ्रेड 1 लॉक हो जाता है, स्थिति की जांच करता है और "कुछ करें" निष्पादित करना शुरू करता है।

अगर मेरे सही ढंग से निम्नलिखित को समझने:

धागा टी तो इस वस्तु के लिए प्रतीक्षा सेट से निकाल दिया जाता है और धागा निर्धारण के लिए फिर से सक्षम। यह वस्तु पर सिंक्रनाइज़ करने के अधिकार के लिए अन्य धागे के साथ सामान्य तरीके से प्रतिस्पर्धा करता है; एक बार जब यह ऑब्जेक्ट पर नियंत्रण प्राप्त कर लेता है, तो ऑब्जेक्ट पर इसके सभी सिंक्रनाइज़ेशन दावों को स्थिति के लिए बहाल किया जाता है - यानी, उस स्थिति के लिए जब प्रतीक्षा विधि लागू की गई थी। थ्रेड टी फिर प्रतीक्षा विधि के आविष्कार से लौटता है। इस प्रकार, प्रतीक्षा विधि से वापस आने पर, ऑब्जेक्ट और थ्रेड टी की सिंक्रनाइज़ेशन स्थिति ठीक वैसे ही होती है जब प्रतीक्षा विधि लागू की जाती थी।

लाइन Systemout.println ("मुझे आह्वान किया गया है!"); निष्पादित नहीं किया जाएगा, "इस प्रकार, प्रतीक्षा विधि से वापस आने पर, ऑब्जेक्ट की सिंक्रनाइज़ेशन स्थिति और थ्रेड टी ठीक उसी तरह है जब प्रतीक्षा विधि लागू की गई थी।"

क्या मैं सही हूँ? Javadoc अंश के लिए