Java मध्ये Wait() पद्धत

या लेखात, आम्ही थ्रेड नियंत्रित करण्यासाठी प्रतीक्षा() पद्धत आणि notify() / notifyAll() पद्धती पाहू . या पद्धती बेस क्लास java.lang.Object मध्ये परिभाषित केल्या आहेत आणि त्यानुसार, Java मध्ये असलेल्या इनहेरिटन्स मेकॅनिझम या पद्धती पूर्णपणे सर्व वर्गांना प्रदान करतात. म्हणजेच, जेव्हा तुम्ही तुमचा स्वतःचा वर्ग आणि त्याचे ऑब्जेक्ट्स तयार करता तेव्हा तुम्ही या पद्धतींना नेहमी कॉल करू शकता.

प्रतीक्षा() आणि notify()/notifyAll() पद्धती कशा कार्य करतात?

• प्रतीक्षा करा() . थोडक्यात, ही पद्धत मॉनिटर रिलीझ करते आणि कॉलिंग थ्रेडला प्रतीक्षा स्थितीत ठेवते जोपर्यंत दुसरा थ्रेड notify() / notifyAll() पद्धतीला कॉल करत नाही;
• सूचित करा() . थ्रेडचे कार्य सुरू ठेवते ज्याची प्रतीक्षा() पद्धत पूर्वी कॉल केली गेली होती;
• notifyAll() मेथड सर्व थ्रेड्स पुन्हा सुरू करते ज्यांना पूर्वी त्यांची wait() पद्धत कॉल केली होती.

आता प्रतीक्षा() पद्धत जवळून पाहू . ऑब्जेक्ट क्लासमध्ये या पद्धतीसाठी तीन पर्याय आहेत:

• पब्लिक फायनल नेटिव्ह व्हॉइड वेट(लाँग टाइमआउटमिलिस) इंटरप्टेडएक्सेप्शन फेकते ; यामुळे वर्तमान थ्रेड जागृत होईपर्यंत प्रतीक्षा करावी लागते. सामान्यतः हे सूचित करून किंवा व्यत्यय आणून किंवा ठराविक वेळ संपेपर्यंत घडते.

• सार्वजनिक अंतिम शून्य प्रतीक्षा() InterruptedException फेकते . आम्ही दुसरी पद्धत म्हणून पॅरामीटर्सशिवाय पद्धत लिहिली हा योगायोग नाही. खरं तर, जर तुम्ही त्याचा कोड पाहिला, तर तो पद्धतीच्या पहिल्या प्रकाराचा संदर्भ देतो, त्यात फक्त 0L युक्तिवाद आहे.

• सार्वजनिक अंतिम प्रतीक्षा (दीर्घ कालबाह्य, इंट नॅनो) . वर्तमान थ्रेडला जागृत होईपर्यंत प्रतीक्षा करण्यास प्रवृत्त करते, विशेषत: सूचित करून किंवा व्यत्यय येईपर्यंत किंवा रिअल टाइमची ठराविक रक्कम संपेपर्यंत.

प्रतीक्षा () पद्धत कॉलिंग थ्रेड निलंबित करण्याच्या उद्देशाने आहे. याचा अर्थ काय? या पद्धती वर्गाच्या आहेत. वर्गावर आधारित, तुम्ही एक ऑब्जेक्ट तयार करता. काही थ्रेड्समध्ये वस्तू अस्तित्वात आहेत. म्हणजेच काही थ्रेडमध्ये वस्तू तयार होतात. ज्या थ्रेडमध्ये हे ऑब्जेक्ट काम करते, त्यामध्ये जर तुम्ही wait() कॉल केलात , तर हा थ्रेड थांबेल हे सत्य ठरेल. ऑब्जेक्ट स्वतः एक प्रकारचे मॉनिटर म्हणून कार्य करते. हे काय आहे? हे स्पष्ट आहे की आपण भिन्न वस्तू तयार करू शकता आणि त्या सर्वांमध्ये प्रतीक्षा () असेलपद्धत कोणत्या ऑब्जेक्टमुळे विशिष्ट थ्रेड थांबला याची समज आहे. थ्रेड थांबतो आणि जोपर्यंत तो पॅरामीटरमध्ये लिहिला जातो तोपर्यंत प्रतीक्षा करेल. आणि मग ते सुरू होईल. हा धागा स्वतःच सुरू होऊ शकत नाही. काम पुन्हा सुरू करण्यासाठी, सूचित करा आणि सूचित करा सर्व पद्धती आहेत. अधिसूचित () किंवा सर्व सूचना () करण्यासाठी कॉल इतर काही थ्रेड प्ले करणे आवश्यक आहे. wait() सह , तुम्ही अनेक थ्रेड्स थांबवू शकता आणि सर्व थ्रेड्स notifyAll() ने सुरू करू शकता . जर एकापेक्षा जास्त थ्रेड्स थांबवले असतील आणि notify() कॉल केला असेल, तर कोणता थ्रेड ही पद्धत पुन्हा सुरू करेल हे सांगणे अशक्य आहे. प्रतीक्षा () पद्धतीवर कोणतेही वेटिंग थ्रेड नसल्यास , सूचना() किंवा तेव्हा काहीही होत नाहीnotifyAll() म्हणतात. थ्रेड एखाद्या विशिष्ट ऑब्जेक्टवर प्रतीक्षा() किंवा सूचित() पद्धतींना कॉल करू शकतो, जर त्या ऑब्जेक्टवर सध्या लॉक असेल. wait() , notify() , आणि notifyAll() फक्त सिंक्रोनाइझ केलेल्या कोडवरून कॉल केले पाहिजेत.

प्रतीक्षा () पद्धतीचे उदाहरण

येथे आम्हाला सर्वात लोकप्रिय उदाहरणांपैकी एक मिळाले आहे जी पद्धत कशी कार्य करते हे स्पष्ट करते. समजा आमच्याकडे एक स्टोअर, एक निर्माता आणि एक ग्राहक आहे. निर्माता उत्पादनाची काही उत्पादने स्टोअरमध्ये हस्तांतरित करतो, त्यानंतर ग्राहक त्यांना घेऊ शकतात. निर्मात्याला अनुक्रमे 8 वस्तू तयार कराव्या लागतील, ग्राहकाने त्या सर्व खरेदी केल्या पाहिजेत. परंतु त्याच वेळी, गोदामात एकाच वेळी 6 पेक्षा जास्त वस्तू असू शकत नाहीत. या समस्येचे निराकरण करण्यासाठी, आम्ही wait() आणि notify() पद्धती वापरतो. चला तीन वर्ग परिभाषित करू: बाजार , उत्पादक आणि ग्राहक . रन () पद्धतीतील उत्पादक त्याचा वापर करून मार्केट ऑब्जेक्टमध्ये 8 उत्पादने जोडतोput() पद्धत. लूपमधील रन() पद्धतीतील क्लायंट ही उत्पादने मिळविण्यासाठी मार्केट ऑब्जेक्टच्या गेट मेथडला कॉल करतो . मार्केट क्लासच्या पुट आणि गेट पद्धती समक्रमित केल्या आहेत. मार्केट क्लासमध्ये वस्तूंच्या उपस्थितीचा मागोवा घेण्यासाठी , आम्ही आयटम व्हेरिएबलचे मूल्य तपासतो. उत्पादन मिळविण्यासाठी get () पद्धत कमीतकमी एक उत्पादन असल्यासच सक्रिय केली पाहिजे. म्हणून, गेट पद्धतीमध्ये, आम्ही उत्पादन गहाळ आहे का ते तपासतो. आयटम उपलब्ध नसल्यास, प्रतीक्षा() पद्धत कॉल केली जाते. ही पद्धत मार्केट ऑब्जेक्टचे मॉनिटर रिलीझ करते आणि सूचना() होईपर्यंत गेट मेथड ब्लॉक करते.पद्धत समान मॉनिटरवर कॉल केली जाते. पुट() मेथडमध्‍ये आयटम जोडला जातो आणि notify() कॉल केला जातो, तेव्हा get() मेथड मॉनिटर मिळवते. त्यानंतर, आमच्या क्लायंटला एक आयटम प्राप्त होतो. हे करण्यासाठी, एक संदेश प्रदर्शित केला जातो आणि आयटमचे मूल्य कमी केले जाते. शेवटी, notify() मेथड कॉल पुट () मेथड चालू ठेवण्यासाठी सिग्नल करते. पुट() पद्धतीत , तत्सम लॉजिक कार्य करते, फक्त आता पुट() पद्धत जर मार्केटमध्ये 6 पेक्षा जास्त उत्पादने नसतील तर कार्य करते .

class Market {

   private int item = 0;

   public synchronized void get() {
       //here we use wait() method
       while (item < 1) {
           try {
               wait();
           }
           catch (InterruptedException e) {
           }
       }
       item--;
       System.out.println("A client has bought 1 item...");
       System.out.println("Items quantity in Market warehouse... " + item);
       notify();
   }

   public synchronized void put() {
       //here we use wait() method when the Warehouse is full
       while (item >= 6) {
           try {
               wait();
           }
           catch (InterruptedException e) {
           }
       }
       item ++;
       System.out.println("Manufacturer has added 1 more item...");
       System.out.println("Now there are " + item + " items in Warehouse" );
       notify();
   }
}

class Manufacturer implements Runnable {

   Market market;

   Manufacturer(Market market) {
       this.market = market;
   }


   public void run() {
       for (int i = 0; i < 8; i++) {
           market.put();
       }
   }
}

class Client implements Runnable {

   Market market;
   Client(Market market) {
       this.market = market;
   }
   public void run() {
       for (int i = 0; i < 8; i++) {
           market.get();
       }
   }
}
//wait() method test class
public class WaitTest {
   public static void main(String[] args) {

       Market market = new Market();
       Manufacturer manufacturer = new Manufacturer(market);
       Client client = new Client(market);
       new Thread(manufacturer).start();
       new Thread(client).start();
   }
}

येथे, get() पद्धतीमध्ये wait() वापरून, आम्ही निर्माता नवीन आयटम जोडण्याची वाट पाहत आहोत . आणि जोडल्यानंतर, आम्ही notify() ला कॉल करतो , जसे की वेअरहाऊसवर एक जागा मोकळी झाली आहे , आणि तुम्ही आणखी जोडू शकता. put() पद्धतीमध्ये wait() वापरून , आम्ही वेअरहाऊसवरील जागा सोडण्याची वाट पाहत आहोत . जागा मोकळी झाल्यानंतर, आम्ही आयटम जोडतो, notify() थ्रेड सुरू करतो आणि क्लायंट आयटम उचलू शकतो. आमच्या प्रोग्रामचे आउटपुट येथे आहे: