"प्रतीक्षा-सूचना-सूचना सर्व" धोरण

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

"मला प्रतीक्षा-सूचना संदर्भात तुमच्याशी खोलवर जायचे आहे. प्रतीक्षा-सूचना पद्धती थ्रेड्सना संवाद साधण्यासाठी एक सोयीस्कर यंत्रणा प्रदान करतात. त्यांचा वापर थ्रेड परस्परसंवादासाठी जटिल उच्च-स्तरीय यंत्रणा तयार करण्यासाठी देखील केला जाऊ शकतो."

"मी एका छोट्या उदाहरणाने सुरुवात करेन. समजा आपल्याकडे सर्व्हरसाठी एक प्रोग्राम आहे ज्याने वेबसाइटद्वारे वापरकर्त्यांनी तयार केलेली विविध कार्ये करणे आवश्यक आहे. वापरकर्ते वेगवेगळ्या वेळी विविध कार्ये जोडू शकतात. कार्ये संसाधन-केंद्रित आहेत, परंतु आमच्या सर्व्हरचे 8 -कोर प्रोसेसर सामना करू शकतो. आम्ही सर्व्हरवरील कार्ये कशी करावी?"

"प्रथम, आम्ही वर्कर थ्रेड्सचा एक गट तयार करू, जेवढे प्रोसेसर कोर आहेत. प्रत्येक थ्रेड त्याच्या स्वतःच्या कोरवर चालण्यास सक्षम असेल: थ्रेड एकमेकांमध्ये व्यत्यय आणणार नाहीत आणि प्रोसेसर कोर होणार नाहीत. निष्क्रिय बसा."

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

"तुम्ही मला टास्क ऑब्जेक्टचे उदाहरण देऊ शकता?"

"ते पहा:"

class Factorial implements Runnable
{
 public int n = 0;
 public long result = 1;

 public Factorial (int n)
 {
  this.n = n;
 }

 public void run()
 {
  for (int i = 2; i <= n; i++)
   result *= i;
 }
}

"अजून तरी छान आहे."

"छान. मग रांगेतील वस्तू कशी दिसली पाहिजे याचे परीक्षण करूया. तुम्ही मला त्याबद्दल काय सांगाल?"

"ते थ्रेड-सेफ असणे आवश्यक आहे. ते वापरकर्त्यांकडून प्राप्त करणार्‍या थ्रेडद्वारे टास्क ऑब्जेक्टसह लोड केले जाते आणि नंतर कार्यकर्ता थ्रेडद्वारे कार्ये उचलली जातात."

"हो. आणि काही वेळ कामं संपली तर?"

"मग कामगार थ्रेड्सने आणखी काही होईपर्यंत थांबावे."

"बरोबर आहे. आता कल्पना करा की हे सर्व एकाच रांगेत बांधले जाऊ शकते. ते पहा:"

public class JobQueue
{
 ArrayList jobs = new ArrayList();

 public synchronized void put(Runnable job)
 {
  jobs.add(job);
  this.notifyAll();
 }

 public synchronized Runnable getJob()
 {
  while (jobs.size() == 0)
   this.wait();

  return jobs.remove(0);
 }
}

"आमच्याकडे एक getJob पद्धत आहे जी कार्य सूची रिकामी आहे की नाही हे तपासते. नंतर सूचीमध्ये काहीतरी दिसेपर्यंत थ्रेड स्लीप (प्रतीक्षा) वर जातो."

" पुट पद्धत देखील आहे , जी तुम्हाला सूचीमध्ये एक नवीन कार्य जोडू देते. नवीन कार्य जोडल्याबरोबर, notifyAll पद्धत कॉल केली जाते. या पद्धतीला कॉल केल्याने getJob पद्धतीमध्ये झोपलेल्या सर्व कामगार थ्रेड्स जागृत होतात."

"प्रतीक्षा आणि सूचना पद्धती कशा कार्य करतात हे तुम्हाला पुन्हा आठवत आहे का?"

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

1) धागा झोपतो.

2) थ्रेड तात्पुरते म्यूटेक्स सोडतो (तो जागे होईपर्यंत).

"त्यानंतर, इतर थ्रेड्स सिंक्रोनाइझ केलेल्या ब्लॉकमध्ये प्रवेश करू शकतात आणि तेच म्यूटेक्स घेऊ शकतात."

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

1) या म्युटेक्स ऑब्जेक्टवर वाट पाहणारे सर्व धागे जागृत झाले आहेत.

2) एकदा वर्तमान धागा सिंक्रोनाइझ्ड ब्लॉकमधून बाहेर पडला की, जागृत थ्रेडपैकी एक म्यूटेक्स घेतो आणि त्याचे कार्य सुरू ठेवतो. जेव्हा ते म्युटेक्स सोडते, तेव्हा दुसरा जागृत धागा म्युटेक्स इ. मिळवतो.

"हे अगदी बससारखेच आहे. तुम्ही प्रवेश करता आणि तुमचे भाडे द्यायचे असते, परंतु तेथे एकही ड्रायव्हर नाही. त्यामुळे तुम्हाला "झोप येते". शेवटी, बस खचाखच भरलेली असते, परंतु अद्याप भाडे देण्यासाठी कोणीही नाही. नंतर ड्रायव्हर येतो आणि म्हणतो, "भाडे, कृपया". आणि ही सुरुवात आहे..."

"रंजक तुलना. पण बस काय आहे?"

"ज्युलिओने हे स्पष्ट केले. 21 व्या शतकात या विचित्र गोष्टी वापरल्या जात होत्या."