java - प्रतीक्षा() और नींद() के बीच अंतर




multithreading sleep (20)

थ्रेड में wait() और sleep() बीच क्या अंतर है?

क्या मेरी समझ है कि एक wait() -िंग थ्रेड अभी भी चलने वाले मोड में है और सीपीयू चक्र का उपयोग करता है लेकिन sleep() -इंग किसी भी CPU चक्र का सही उपयोग नहीं करती है?

हमारे पास wait() क्यों है wait() और sleep() : उनका कार्यान्वयन निम्न स्तर पर कैसे भिन्न होता है?


प्रतीक्षा () और नींद () के बीच अंतर

  • मौलिक अंतर wait() Object और sleep() Thread की स्थिर विधि है।

  • मुख्य अंतर यह है कि wait() sleep() दौरान ताला जारी करता है sleep() प्रतीक्षा करते समय किसी भी ताला को जारी नहीं करता है।

  • wait() का उपयोग इंटर-थ्रेड संचार के लिए किया जाता है जबकि sleep() का उपयोग आमतौर पर निष्पादन पर रोक लगाने के लिए किया जाता है।

  • wait() को सिंक्रनाइज़ करने के अंदर से कॉल करना चाहिए या अन्यथा हमें IllegalMonitorStateException मिलता है जबकि sleep() कहीं भी कॉल कर सकती है।

  • wait() से फिर से थ्रेड शुरू करने के लिए, आपको notify() या notify() को कॉल करना होगा। जबकि sleep(), निर्दिष्ट एमएस / सेक अंतराल के बाद धागा शुरू होता है।

समानताएं जो समझने में मदद करती हैं

  • दोनों मौजूदा धागे को चलाने योग्य राज्य में नहीं चलाते हैं
  • दोनों native तरीके हैं।

नींद

  • यह मौजूदा निष्पादन धागे को विशिष्ट समय के लिए सोने का कारण बनता है।
  • इसकी सटीकता सिस्टम टाइमर और शेड्यूलर पर निर्भर करती है।
  • यह मॉनीटर को अधिग्रहित करता है, इसलिए यदि इसे सिंक्रनाइज़ संदर्भ से कहा जाता है, तो कोई अन्य थ्रेड उस ब्लॉक या विधि में प्रवेश नहीं कर सकता है।
  • अगर हम इंटरप्ट () विधि को कॉल करते हैं, तो यह सोते धागे को जगाएगा।

रुकिए

  • यह वर्तमान थ्रेड का इंतजार तब तक करता है जब तक कि कोई अन्य थ्रेड अधिसूचना () विधि या अधिसूचना सभी () विधि को इस ऑब्जेक्ट के लिए आमंत्रित नहीं करता
  • इसे सिंक्रनाइज़ संदर्भ से ब्लॉक या विधि से कहा जाना चाहिए। इसका मतलब है कि प्रतीक्षा () विधि कहने से पहले, वर्तमान थ्रेड उस ऑब्जेक्ट पर लॉक होना चाहिए।
  • यह उस ऑब्जेक्ट पर लॉक जारी करता है जिस पर उसे कॉल किया जाता है और प्रतीक्षा सूची में जोड़ा जाता है, इसलिए कोई अन्य थ्रेड ऑब्जेक्ट पर लॉक प्राप्त कर सकता है।

अभी तक एक महत्वपूर्ण अंतर का उल्लेख नहीं किया गया है कि थ्रेड सोते समय ताले को रिहा नहीं किया जाता है, जबकि प्रतीक्षा करने वाले ऑब्जेक्ट पर लॉक जारी करता है wait() को कॉल किया जाता है।

synchronized(LOCK) {
    Thread.sleep(1000); // LOCK is held
}


synchronized(LOCK) {
    LOCK.wait(); // LOCK is not held
}

आप सही हैं - नींद () धागे को "नींद" का कारण बनती है और सीपीयू बंद हो जाएगा और अन्य धागे को संसाधित करेगा (अन्यथा संदर्भ स्विचिंग के रूप में जाना जाता है) wheras मुझे विश्वास है कि सीपीयू वर्तमान थ्रेड को प्रोसेसिंग करता है।

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

यह भी ध्यान रखें कि नींद एक संदर्भ स्विच बलों।

इसके अलावा - सामान्य रूप से संदर्भ स्विचिंग को नियंत्रित करना संभव नहीं है - प्रतीक्षा करें ओएस के दौरान (और लंबे समय तक प्रतीक्षा करेगा) अन्य धागे को संसाधित करने का चयन करें।


एक wait थ्रेड द्वारा "जागृत" हो सकती है जिसे मॉनीटर पर notify किया जाता है, जिस पर इंतजार किया जा रहा है जबकि sleep नहीं हो सकती है। मॉनिटर ऑब्जेक्ट पर synchronized गए ब्लॉक में भी एक wait (और notify ) होना चाहिए जबकि sleep नहीं है:

Object mon = ...;
synchronized (mon) {
    mon.wait();
} 

इस बिंदु पर वर्तमान में निष्पादित थ्रेड मॉनीटर की प्रतीक्षा करता है और रिलीज़ करता है । एक और धागा कर सकता है

synchronized (mon) { mon.notify(); }

(एक ही mon ऑब्जेक्ट पर) और पहला धागा (माना जाता है कि यह मॉनिटर पर प्रतीक्षा करने वाला एकमात्र धागा है) जाग जाएगा।

यदि आप मॉनिटर पर एक से अधिक थ्रेड इंतजार कर रहे हैं तो आप notifyAll भी कॉल कर सकते हैं - यह उन सभी को notifyAll । हालांकि, धागे में से केवल एक ही मॉनीटर को पकड़ने में सक्षम होगा (याद रखें कि wait synchronized ब्लॉक में है) और आगे बढ़ें - अन्य तब तक अवरुद्ध हो जाएंगे जब तक वे मॉनिटर लॉक प्राप्त नहीं कर लेते।

एक और मुद्दा यह है कि आप Object पर wait करें (यानी आप ऑब्जेक्ट की मॉनिटर पर प्रतीक्षा करें) जबकि आप Thread पर sleep कहते sleep

फिर भी एक और मुद्दा यह है कि आप wait से नकली जागरूकता प्राप्त कर सकते हैं (यानी थ्रेड जो किसी भी स्पष्ट कारण के लिए इंतजार कर रहा है)। निम्न शर्त पर कताई करते समय आपको हमेशा wait करनी चाहिए:

synchronized {
    while (!condition) { mon.wait(); }
}

नींद / बाधा के बीच एक संभावित बड़ा अंतर और प्रतीक्षा / अधिसूचना यह है

  • sleep दौरान t.interrupt() कॉल करना sleep हमेशा एक अपवाद फेंकता है (उदाहरण के लिए InterruptedException एक्सेप्शन), जबकि
  • wait() दौरान notify नहीं करता है।

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


मुझे यह लिंक उपयोगी पाया (जो इस पोस्ट का संदर्भ देता है)। यह मानव शर्तों में sleep() , wait() , और yield() बीच का अंतर डालता है। (यदि लिंक कभी मृत हो जाते हैं तो मैंने अतिरिक्त मार्कअप के साथ नीचे पोस्ट शामिल किया है)

यह सब अंततः ओएस के शेड्यूलर के लिए अपना रास्ता बना देता है, जो प्रक्रियाओं और धागे के लिए समय-समय पर हाथ रखता है।

sleep(n) कहती है, "मैं अपने टाइमलाइस के साथ कर रहा हूं, और कृपया मुझे कम से कम एन मिलीसेकंड के लिए एक और न दें।" ओएस अनुरोध समय समाप्त होने तक सोने के थ्रेड को शेड्यूल करने का भी प्रयास नहीं करता है।

yield() कहती है, "मैं अपने टाइमलाइस के साथ कर रहा हूं, लेकिन मेरे पास अभी भी काम करने के लिए काम है।" ओएस तुरंत थ्रेडल को थ्रेड देने के लिए स्वतंत्र है, या कुछ अन्य थ्रेड देने या सीपीयू को प्रोसेस करने के लिए उपरोक्त थ्रेड को छोड़ दिया गया है ।

.wait() कहते हैं, "मैं अपने .wait() साथ कर रहा हूँ। मुझे किसी अन्य टाइम्सलाइस न दें जब तक कि कोई व्यक्ति सूचित न करे ()। " sleep() साथ sleep() , ओएस आपके कार्य को शेड्यूल करने की कोशिश भी नहीं करेगा जब तक कि कोई व्यक्ति notify() (या कुछ अन्य जागरूकता परिदृश्यों में से एक होता है)।

जब वे आईओ अवरुद्ध करते हैं और कुछ अन्य परिस्थितियों में होते हैं तो थ्रेड भी अपने टाइम टाइलिस को खो देते हैं। यदि कोई थ्रेड पूरे टाइमलाइस के माध्यम से काम करता है, तो ओएस जबरन नियंत्रण रखता है जैसे yield() को बुलाया गया था, ताकि अन्य प्रक्रियाएं चल सकें।

आपको शायद ही कभी yield() की आवश्यकता होती yield() , लेकिन यदि आपके पास तार्किक कार्य सीमाओं के साथ एक गणना-भारी ऐप है, तो yield() डालने से सिस्टम की प्रतिक्रिया में सुधार हो सकता है (समय की कीमत पर - संदर्भ स्विच, यहां तक ​​कि केवल ओएस और पीछे, ' टी मुक्त)। हमेशा के रूप में आप जिन लक्ष्यों की परवाह करते हैं उनके खिलाफ मापें और परीक्षण करें।


यह एक बहुत ही सरल सवाल है, क्योंकि इन दोनों तरीकों का एक पूरी तरह से अलग उपयोग है।

मुख्य अंतर यह है कि लॉक या मॉनीटर को रिहा करने के लिए इंतजार करना है, जबकि नींद प्रतीक्षा करते समय कोई लॉक या मॉनीटर जारी नहीं करती है। प्रतीक्षा का उपयोग इंटर-थ्रेड संचार के लिए किया जाता है जबकि नींद का उपयोग निष्पादन पर रोक लगाने के लिए किया जाता है।

यह सिर्फ एक स्पष्ट और बुनियादी स्पष्टीकरण था, यदि आप उससे अधिक चाहते हैं तो पढ़ना जारी रखें।

wait() विधि थ्रेड प्रतीक्षा स्थिति में जाता है और यह तब तक स्वचालित रूप से वापस नहीं आ जाएगा जब तक हम notify() विधि (या notify() notifyAll() यदि आपके पास प्रतीक्षा स्थिति में एक धागा है और आप सभी को जागना चाहते हैं) वो धागा)। और आपको wait() या notify() या notify() notifyAll() विधियों तक पहुंचने के लिए सिंक्रनाइज़ या ऑब्जेक्ट लॉक या क्लास लॉक की आवश्यकता है। और एक और बात, wait() विधि इंटर-थ्रेड संचार के लिए प्रयोग की जाती है क्योंकि यदि थ्रेड प्रतीक्षा स्थिति में जाता है तो आपको थ्रेड को जगाने के लिए एक और थ्रेड की आवश्यकता होगी।

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

और साक्षात्कार में अक्सर एक और महत्वपूर्ण अंतर पूछा जाता है: sleep() Thread क्लास से संबंधित है और wait() Object क्लास से संबंधित है।

ये sleep() और wait() बीच सभी अंतर हैं।

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

उम्मीद है इससे आपको मदद मिलेगी।


यहां, मैंने wait() और sleep() विधियों के बीच कुछ महत्वपूर्ण अंतर सूचीबद्ध किए हैं।
पीएस: लाइब्रेरी कोड देखने के लिए लिंक पर भी क्लिक करें (आंतरिक काम, बेहतर समझने के लिए बस थोड़ा सा खेलते हैं)।

wait()

  1. wait() विधि लॉक जारी करता है।
  2. wait() Object क्लास की विधि है।
  3. wait() गैर स्थैतिक विधि है - public final void wait() throws InterruptedException { //...}
  4. wait() को अधिसूचित notify() या notifyAll() विधियों द्वारा अधिसूचित किया जाना चाहिए।
  5. झूठा अलार्म से निपटने के लिए wait() विधि को लूप से बुलाया जाना चाहिए।

  6. wait() विधि को सिंक्रनाइज़ संदर्भ (यानी सिंक्रनाइज़ विधि या ब्लॉक) से बुलाया जाना चाहिए, अन्यथा यह IllegalMonitorStateException को फेंक IllegalMonitorStateException

sleep()

  1. sleep() विधि ताला जारी नहीं करता है।
  2. sleep() java.lang.Thread की विधि है। java.lang.Thread क्लास।
  3. sleep() स्थिर विधि है - public static void sleep(long millis, int nanos) throws InterruptedException { //... }
  4. निर्दिष्ट समय के बाद, sleep() पूरा हो गया है।
  5. sleep() बेहतर लूप से कॉल न करें (यानी नीचे कोड देखें )।
  6. sleep() कहीं से भी बुलाया जा सकता है। कोई विशिष्ट आवश्यकता नहीं है।

रेफरी: प्रतीक्षा और नींद के बीच अंतर

प्रतीक्षा और नींद विधि कॉल करने के लिए कोड स्निपेट

synchronized(monitor){
    while(condition == true){ 
        monitor.wait()  //releases monitor lock
    }

    Thread.sleep(100); //puts current thread on Sleep    
}


रुको और सो दो अलग-अलग चीजें हैं:

  • sleep() धागा निर्दिष्ट अवधि के लिए काम करना बंद कर देता है।
  • wait() थ्रेड तब तक काम करना बंद कर देता है जब तक ऑब्जेक्ट का इंतजार नहीं किया जाता है-पर अधिसूचित किया जाता है, आमतौर पर अन्य धागे द्वारा।

सरल शब्दों में, प्रतीक्षा प्रतीक्षा करें जब तक कि कुछ अन्य धागे आपको आमंत्रित न करें, जबकि कुछ निश्चित अवधि के लिए नींद "अगले कथन को निष्पादित न करें"।

इसके अलावा नींद थ्रेड क्लास में स्थिर विधि है और यह थ्रेड पर चलती है, जबकि प्रतीक्षा () ऑब्जेक्ट क्लास में है और ऑब्जेक्ट पर कॉल किया जाता है।

एक और बिंदु, जब आप किसी ऑब्जेक्ट पर प्रतीक्षा करते हैं, तो थ्रेड ऑब्जेक्ट को सिंक्रनाइज़ करता है और फिर प्रतीक्षा करता है। :)


स्रोत: http://www.jguru.com/faq/view.jsp?EID=47127

sleep वर्तमान धागे को कुछ समय के लिए " sleep नहीं" स्थिति में भेजता है। थ्रेड उस मॉनीटर को रखता है जो इसे प्राप्त करता है - यानी यदि थ्रेड वर्तमान में सिंक्रनाइज़ ब्लॉक या विधि में है, तो कोई अन्य थ्रेड इस ब्लॉक या विधि में प्रवेश नहीं कर सकता है। यदि कोई अन्य धागा t.interrupt() कॉल t.interrupt() यह सोने के थ्रेड को t.interrupt()

ध्यान दें कि नींद एक स्थिर विधि है, जिसका अर्थ है कि यह हमेशा मौजूदा धागे को प्रभावित करता है (वह जो नींद विधि निष्पादित कर रहा है)। एक सामान्य गलती है t.sleep() को कॉल t.sleep() जहां टी एक अलग धागा है; फिर भी, यह वर्तमान धागा है जो सो जाएगा, टी धागा नहीं।

t.suspend() बहिष्कृत है। मौजूदा थ्रेड के अलावा किसी धागे को रोकना संभव है। एक निलंबित धागा अपने सभी मॉनीटर रखता है और चूंकि यह स्थिति बाधित नहीं होती है, यह डेडलॉक प्रवण है।

wait वर्तमान थ्रेड को "नहीं चलने योग्य" स्थिति में भेजता है, जैसे sleep() , लेकिन मोड़ के साथ। प्रतीक्षा वस्तु को बुलाया जाता है, धागा नहीं; हम इस ऑब्जेक्ट को "लॉक ऑब्जेक्ट" कहते हैं। lock.wait() को कॉल करने से पहले, वर्तमान थ्रेड को लॉक ऑब्जेक्ट पर सिंक्रनाइज़ करना होगा; wait() फिर इस लॉक को रिलीज़ करता है, और ताला को लॉक से जुड़े "प्रतीक्षा सूची" में जोड़ता है। बाद में, एक और धागा एक ही लॉक ऑब्जेक्ट पर सिंक्रनाइज़ कर सकता है और lock.notify() कॉल कर lock.notify() । यह मूल, प्रतीक्षा थ्रेड उठता है। असल में, wait() / notify() sleep() की तरह है sleep() / interrupt() , केवल सक्रिय थ्रेड को सोने के थ्रेड पर प्रत्यक्ष सूचक की आवश्यकता नहीं है, लेकिन केवल साझा लॉक ऑब्जेक्ट के लिए।


sleep Thread की एक विधि है, wait Object की एक विधि है, इसलिए wait/notify जावा में साझा डेटा सिंक्रनाइज़ करने की तकनीक ( monitor का उपयोग करके), लेकिन sleep खुद को रोकने के लिए धागे की एक साधारण विधि है।


wait releases the lock and sleep doesn't. A thread in waiting state is eligible for waking up as soon as notify or notifyAll is called. But in case of sleep the thread keeps the lock and it'll only be eligible once the sleep time is over.


Should be called from synchronized block : wait() method is always called from synchronized block ie wait() method needs to lock object monitor before object on which it is called. But sleep() method can be called from outside synchronized block ie sleep() method doesn't need any object monitor.

IllegalMonitorStateException : if wait() method is called without acquiring object lock than IllegalMonitorStateException is thrown at runtime, but sleep() method never throws such exception.

Belongs to which class : wait() method belongs to java.lang.Object class but sleep() method belongs to java.lang.Thread class.

Called on object or thread : wait() method is called on objects but sleep() method is called on Threads not objects.

Thread state : when wait() method is called on object, thread that holded object's monitor goes from running to waiting state and can return to runnable state only when notify() or notifyAll() method is called on that object. And later thread scheduler schedules that thread to go from from runnable to running state. when sleep() is called on thread it goes from running to waiting state and can return to runnable state when sleep time is up.

When called from synchronized block : when wait() method is called thread leaves the object lock. But sleep() method when called from synchronized block or method thread doesn't leaves object lock.

For More Reference


नींद () एक विधि है जिसका उपयोग कुछ सेकंड या आपके इच्छित समय के लिए प्रक्रिया को पकड़ने के लिए किया जाता है, लेकिन प्रतीक्षा () विधि थ्रेड प्रतीक्षा स्थिति में जाता है और जब तक हम अधिसूचना () या कॉल को कॉल नहीं करते हैं, तब तक यह स्वचालित रूप से वापस नहीं आ जाएगा notifyAll ()।

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

Thread.sleep () वर्तमान धागे को कुछ समय के लिए " चलाने योग्य नहीं" स्थिति में भेजता है। थ्रेड उस मॉनीटर को रखता है जो उसने अधिग्रहित किया है - यानी यदि थ्रेड वर्तमान में सिंक्रनाइज़ ब्लॉक या विधि में है, तो कोई अन्य थ्रेड इस ब्लॉक या विधि में प्रवेश नहीं कर सकता है। यदि कोई अन्य धागा t.interrupt () को कॉल करता है तो यह सोने के थ्रेड को जगाएगा। ध्यान दें कि नींद एक स्थिर विधि है, जिसका अर्थ है कि यह हमेशा मौजूदा धागे को प्रभावित करता है (वह जो नींद विधि निष्पादित कर रहा है)। एक सामान्य गलती है t.sleep () को कॉल करना जहां टी एक अलग धागा है; फिर भी, यह वर्तमान धागा है जो सो जाएगा, टी धागा नहीं।

object.wait () वर्तमान थ्रेड को "नहीं चलने योग्य" स्थिति में भेजता है, जैसे नींद (), लेकिन मोड़ के साथ। प्रतीक्षा वस्तु को बुलाया जाता है, धागा नहीं; हम इस ऑब्जेक्ट को "लॉक ऑब्जेक्ट" कहते हैं। lock.wait () को कॉल करने से पहले, वर्तमान थ्रेड को लॉक ऑब्जेक्ट पर सिंक्रनाइज़ करना होगा; प्रतीक्षा करें () फिर इस लॉक को रिलीज़ करता है, और ताला को लॉक से जुड़े "प्रतीक्षा सूची" में जोड़ता है। बाद में, एक और धागा एक ही लॉक ऑब्जेक्ट पर सिंक्रनाइज़ कर सकता है और lock.notify () को कॉल कर सकता है। यह मूल, प्रतीक्षा थ्रेड उठता है। असल में, प्रतीक्षा करें () / अधिसूचित () नींद की तरह है () / इंटरप्ट (), केवल सक्रिय थ्रेड को सोने के थ्रेड पर प्रत्यक्ष सूचक की आवश्यकता नहीं है, लेकिन केवल साझा लॉक ऑब्जेक्ट के लिए।

synchronized(LOCK) {   
   Thread.sleep(1000); // LOCK is held
}

synchronized(LOCK) {   
   LOCK.wait(); // LOCK is not held
}

सभी उपरोक्त बिंदुओं को वर्गीकृत करने दें:

Call on:

  • प्रतीक्षा करें (): किसी ऑब्जेक्ट पर कॉल करें; वर्तमान धागे को लॉक ऑब्जेक्ट पर सिंक्रनाइज़ करना होगा।
  • नींद (): थ्रेड पर कॉल करें; हमेशा वर्तमान में धागा निष्पादित।

Synchronized:

  • प्रतीक्षा करें (): जब एकाधिक धागे सिंक्रनाइज़ किए जाते हैं तो एक ही ऑब्जेक्ट को एक-एक करके एक्सेस करें।
  • नींद (): जब कई धागे सिंक्रनाइज़ होते हैं तो सोने के धागे के ऊपर सोने की प्रतीक्षा करें।

Hold lock:

  • प्रतीक्षा करें (): निष्पादित करने का मौका पाने के लिए अन्य ऑब्जेक्ट्स के लिए लॉक जारी करें।
  • नींद (): टाइमआउट निर्दिष्ट होने पर या किसी को बाधित होने पर कम से कम टी बार लॉक रखें।

Wake-up condition:

  • प्रतीक्षा करें (): जब तक कॉल अधिसूचित (), ऑब्जेक्ट से सभी () सूचित करें
  • नींद (): कम से कम समय समाप्त होने तक या इंटरप्ट को कॉल करें ()।

Usage:

  • नींद (): समय-सिंक्रनाइज़ेशन के लिए;
  • प्रतीक्षा करें (): बहु-थ्रेड-सिंक्रनाइज़ेशन के लिए।

रेफरी: sleep और wait


From oracle documentation page on wait() method of Object :

public final void wait()
  1. Causes the current thread to wait until another thread invokes the notify() method or the notifyAll() method for this object. In other words, this method behaves exactly as if it simply performs the call wait(0) .
  2. The current thread must own this object's monitor. The thread releases ownership of this monitor and waits until another thread notifies threads waiting on this object's monitor to wake up
  3. interrupts and spurious wakeups are possible
  4. This method should only be called by a thread that is the owner of this object's monitor

This method throws

  1. IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.

  2. InterruptedException - if any thread interrupted the current thread before or while the current thread was waiting for a notification. The interrupted status of the current thread is cleared when this exception is thrown.

From oracle documentation page on sleep() method of Thread class:

public static void sleep(long millis)
  1. Causes the currently executing thread to sleep (temporarily cease execution) for the specified number of milliseconds, subject to the precision and accuracy of system timers and schedulers.
  2. The thread does not lose ownership of any monitors.

This method throws:

  1. IllegalArgumentException - if the value of millis is negative

  2. InterruptedException - if any thread has interrupted the current thread. The interrupted status of the current thread is cleared when this exception is thrown.

Other key difference:

wait() is a non-static method (instance method) unlike static method sleep() (class method).


Here wait() will be in the waiting state till it notify by another Thread but where as sleep() will be having some time..after that it will automatically transfer to the Ready state...


Lets assume you are hearing songs.

As long as the current song is running, the next song wont play, ie Sleep() called by next song

If you finish the song it will stop and until you select play button(notify()) it wont play, ie wait() called by current song.

In this both cases songs going to Wait states.


Wait() and sleep() Differences?

Thread.sleep() Once its work completed then only its release the lock to everyone. until its never release the lock to anyone.

  Sleep() take the key, its never release the key to anyone, when its work completed then only its release then only take the key waiting stage threads.

Object.wait() When its going to waiting stage, its will be release the key and its waiting for some of the seconds based on the parameter.

उदाहरण के लिए:

you are take the coffee in yours right hand, you can take another anyone of the same hand, when will your put down then only take another object same type here. also. this is sleep() you sleep time you didn't any work, you are doing only sleeping.. same here also.

wait(). when you are put down and take another one mean while you are waiting , that's wait

you are play movie or anything in yours system same as player you can't play more than one at a time right, thats its here, when you close and choose another anyone movie or song mean while is called wait





java-threads