प्रतीक्षा करा, सूचित करा आणि सूचित करा सर्व पद्धती

"हाय, अमिगो!"

"हाय, ऋषी!"

"मी तुम्हाला ऑब्जेक्ट क्लासच्या प्रतीक्षा , सूचना आणि सूचना सर्व पद्धतींशी परिचय करून देणार आहे."

"आज आम्ही फक्त त्यांच्याशी परिचित होऊ, परंतु आम्ही नंतर परत येऊ आणि यावर अधिक वेळ घालवू."

"ठीक आहे."

"या पद्धती थ्रेड सिंक्रोनाइझेशन यंत्रणेचा भाग म्हणून शोधल्या गेल्या होत्या."

"मी तुम्हाला आठवण करून देतो की Java मध्ये वेगवेगळ्या थ्रेड्समधून सामायिक केलेल्या संसाधनांवर (ऑब्जेक्ट्स) प्रवेश नियंत्रित करण्यासाठी अंगभूत यंत्रणा आहे. एक थ्रेड घोषित करू शकतो की ऑब्जेक्ट व्यस्त आहे आणि इतर थ्रेड्सला व्यस्त ऑब्जेक्ट रिलीज होईपर्यंत प्रतीक्षा करावी लागेल. "

"मला आठवतं. तुम्ही ते सिंक्रोनाइझ केलेला कीवर्ड वापरून करता ."

"बरोबर. सामान्यतः, कोड असे काहीतरी दिसेल:"

public void print()
{
 Object monitor = getMonitor();
 synchronized(monitor)
 {
  System.out.println("text");
 }
}

"हे कसे कार्य करते ते लक्षात ठेवा?"

"हो. जर दोन थ्रेड्स एकाच वेळी print() पद्धतीला कॉल करत असतील, तर त्यापैकी एक सिंक्रोनाइझ केलेल्या ब्लॉकमध्ये प्रवेश करेल आणि मॉनिटर लॉक करेल, ज्यामुळे दुसरा थ्रेड मॉनिटर रिलीज होईपर्यंत प्रतीक्षा करेल."

"बरोबर. एकदा थ्रेड सिंक्रोनाइझ केलेले लेबल असलेल्या ब्लॉकमध्ये प्रवेश केल्यावर, मॉनिटर ऑब्जेक्ट व्यस्त म्हणून चिन्हांकित केले जाईल आणि इतर थ्रेड्सना मॉनिटर ऑब्जेक्ट रिलीज होण्याची प्रतीक्षा करण्यास भाग पाडले जाईल. समान मॉनिटर ऑब्जेक्ट प्रोग्रामच्या विविध भागांमध्ये वापरला जाऊ शकतो. "

"बाय द वे, तुम्ही मॉनिटर हे नाव का निवडले?"

"मॉनिटर म्हणजे ज्याला तुम्ही सामान्यत: व्यस्त किंवा विनामूल्य स्थिती साठवून ठेवणारी वस्तू म्हणता."

"आणि इथेच प्रतीक्षा आणि सूचना पद्धती लागू होतात."

"वास्तविक, या दोनच पद्धती आहेत. इतर फक्त या पद्धतींचे रुपांतर आहेत."

"आता वाट पाहण्याची पद्धत काय आहे आणि आपल्याला त्याची गरज का आहे याभोवती आपले डोके गुंडाळूया . "

"कधीकधी प्रोग्राममध्ये अशी परिस्थिती असते जेथे थ्रेड सिंक्रोनाइझ केलेल्या कोडच्या ब्लॉकमध्ये प्रवेश करतो आणि मॉनिटर लॉक करतो, परंतु पुढे चालू ठेवू शकत नाही कारण त्यात काही डेटा गहाळ आहे. उदाहरणार्थ, ज्या फाइलवर प्रक्रिया करणे आवश्यक आहे ती डाउनलोड करणे पूर्ण झाले नाही किंवा तशा प्रकारे काहीतरी."

"आम्ही फाईल डाउनलोड होण्याची वाट पाहू शकतो. तुम्ही फक्त लूप वापरून ती तपासू शकता. जर फाइल अजून डाउनलोड झाली नसेल, तर काही सेकंद झोपा आणि ती डाउनलोड होईपर्यंत पुन्हा तपासा."

"यासारखेच काहीसे:"

while(!file.isDownloaded())
{
 Thread.sleep(1000);
}
processFile(file);

"परंतु आमच्या बाबतीत, या प्रकारची प्रतीक्षा खूप महाग आहे. आमच्या थ्रेडने मॉनिटर लॉक केल्यामुळे, इतर थ्रेड्सना देखील प्रतीक्षा करणे भाग पडते जरी त्यांच्याकडे आधीच आवश्यक असलेला डेटा असेल."

या समस्येचे निराकरण करण्यासाठी प्रतीक्षा () पद्धतीचा शोध लावला गेला. या पद्धतीमुळे थ्रेड मॉनिटर सोडतो आणि नंतर थ्रेडला «सस्पेंड» करतो.

"तुम्ही मॉनिटर ऑब्जेक्टची प्रतीक्षा पद्धत कॉल करू शकता जेव्हा मॉनिटर व्यस्त असतो, म्हणजे फक्त सिंक्रोनाइझ केलेल्या ब्लॉकमध्ये. जेव्हा असे होते, तेव्हा थ्रेड तात्पुरते चालणे थांबवते, आणि मॉनिटर सोडला जातो जेणेकरून इतर थ्रेड्स त्याचा वापर करू शकतील."

"अनेकदा अशी उदाहरणे आहेत की थ्रेड सिंक्रोनाइझ ब्लॉकमध्ये प्रवेश करेल आणि कॉल प्रतीक्षा करेल, अशा प्रकारे मॉनिटर रिलीझ होईल."

"मग दुसरा थ्रेड प्रविष्ट होईल आणि निलंबित केला जाईल, नंतर तिसरा, आणि असेच."

"आणि धागा पुन्हा कसा सुरू होतो?"

"त्यासाठी, दुसरी पद्धत आहे: सूचित करा."

" मॉनिटर व्यस्त असताना तुम्ही फक्त मॉनिटर ऑब्जेक्टच्या सूचना / सूचना सर्व पद्धतींना कॉल करू शकता, म्हणजे फक्त सिंक्रोनाइझ केलेल्या ब्लॉकमध्ये. notifyAll पद्धत या मॉनिटर ऑब्जेक्टवर वाट पाहत असलेले सर्व थ्रेड्स जागृत करते."

" सूचना पद्धत एक यादृच्छिक थ्रेडला 'अनफ्रीझ' करते, परंतु नोटिफाय ऑल पद्धत या मॉनिटरचे सर्व «फ्रोझन» थ्रेड्स अनफ्रीझ करते."

"खूप इंटरेस्टिंग. धन्यवाद, ऋषी."

"वेट() पद्धतीचे रुपांतर देखील आहेत:"

void wait(long timeout)

void wait(long timeout, int nanos)

"आम्ही याला टाइमआउटसह प्रतीक्षा देखील म्हणतो. पद्धत सामान्य प्रतीक्षासारखी कार्य करते, परंतु जर निर्दिष्ट वेळ निघून गेली असेल आणि थ्रेड जागृत झाला नसेल, तर ती स्वतःच उठते."