जावा में प्रतीक्षा करें () विधि

इस लेख में, हम थ्रेड को नियंत्रित करने के लिए प्रतीक्षा () विधि और सूचित () / InformAll () विधियों को देखेंगे । इन विधियों को बेस क्लास java.lang.Object में परिभाषित किया गया है और तदनुसार, विरासत तंत्र जो जावा में हैं, इन विधियों को पूरी तरह से सभी वर्गों को प्रदान करते हैं। यही है, जब आप अपनी खुद की कक्षा और उसके ऑब्जेक्ट बनाते हैं, तो आप हमेशा इन विधियों को कॉल कर सकते हैं।

प्रतीक्षा () और सूचित () / सूचित करें () विधियाँ कैसे काम करती हैं?

• प्रतीक्षा करें () । संक्षेप में, यह विधि मॉनिटर को रिलीज़ करती है और कॉलिंग थ्रेड को तब तक प्रतीक्षा स्थिति में रखती है जब तक कि कोई अन्य थ्रेड नोटिफ़िकेशन () / InformAll () विधि को कॉल नहीं करता;
• सूचित करें () । उस थ्रेड का काम जारी रखता है जिसकी प्रतीक्षा () विधि को पहले बुलाया गया था;
• InformAll () विधि उन सभी थ्रेड्स को फिर से शुरू करती है जिन्हें पहले उनकी प्रतीक्षा () विधि कहा जाता था।

आइए अब प्रतीक्षा () विधि पर करीब से नज़र डालें। इस पद्धति के लिए ऑब्जेक्ट क्लास में तीन विकल्प हैं:

• सार्वजनिक अंतिम मूल शून्य प्रतीक्षा (लंबे समय तक मिलिस) इंटरप्टेड एक्सेप्शन फेंकता है ; यह वर्तमान थ्रेड को जगाए जाने तक प्रतीक्षा करने का कारण बनता है। आमतौर पर यह अधिसूचित या बाधित होने से होता है, या जब तक कि वास्तविक समय की एक निश्चित मात्रा समाप्त नहीं हो जाती।

• सार्वजनिक अंतिम शून्य प्रतीक्षा () इंटरप्टेड अपवाद फेंकता है । यह कोई संयोग नहीं है कि हमने पैरामीटर के बिना दूसरे के रूप में एक विधि लिखी। वास्तव में, यदि आप इसके कोड को देखते हैं, तो यह विधि के पहले संस्करण को संदर्भित करता है, इसमें केवल 0L तर्क है।

• सार्वजनिक अंतिम प्रतीक्षा (लंबा समय समाप्त, int nanos) । वर्तमान थ्रेड को तब तक प्रतीक्षा करने का कारण बनता है जब तक कि यह जागृत न हो जाए, आमतौर पर अधिसूचित या बाधित होने तक, या जब तक कि वास्तविक समय की एक निश्चित मात्रा समाप्त नहीं हो जाती।

प्रतीक्षा () विधि का उद्देश्य कॉलिंग थ्रेड को निलंबित करना है। इसका मतलब क्या है? ये तरीके वर्ग के हैं। वर्ग के आधार पर आप एक वस्तु बनाते हैं। कुछ धागों में वस्तुएँ मौजूद हैं। यानी कुछ थ्रेड्स में ऑब्जेक्ट्स बनाए जाते हैं। जिस थ्रेड में यह ऑब्जेक्ट काम करता है, यदि आप इसमें प्रतीक्षा () कहते हैं, तो यह इस तथ्य को जन्म देगा कि यह थ्रेड बंद हो जाएगा। ऑब्जेक्ट ही एक तरह के मॉनिटर का काम करता है। क्या है वह? यह स्पष्ट है कि आप अलग-अलग ऑब्जेक्ट बना सकते हैं और उन सभी में प्रतीक्षा होगी ()तरीका। इस बात की समझ है कि किस वस्तु ने किसी विशेष धागे को रोक दिया। थ्रेड बंद हो जाता है और जब तक यह पैरामीटर में लिखा जाता है तब तक प्रतीक्षा करेगा। और फिर यह शुरू हो जाएगा। यह थ्रेड अपने आप प्रारंभ नहीं हो सकता. काम फिर से शुरू करने के लिए, सूचित करें और सूचित करें सभी तरीके हैं। सूचित करने के लिए एक कॉल () या InformAll () को कुछ अन्य थ्रेड खेलना चाहिए। प्रतीक्षा करें () के साथ , आप कई थ्रेड्स को रोक सकते हैं और सभी थ्रेड्स को InformAll () के साथ शुरू कर सकते हैं । यदि एकाधिक धागे बंद कर दिए गए थे और सूचित किया गया था () कहा गया था, तो यह बताना असंभव है कि कौन सा धागा इस विधि को फिर से शुरू करेगा। यदि प्रतीक्षा () विधि पर कोई प्रतीक्षा सूत्र नहीं है, तो सूचित करने पर कुछ नहीं होता है () ।InformAll() कहा जाता है। एक थ्रेड किसी विशेष ऑब्जेक्ट पर प्रतीक्षा () या सूचित () विधियों को तभी कॉल कर सकता है जब वर्तमान में उस ऑब्जेक्ट पर लॉक हो। प्रतीक्षा करें () , सूचित करें () , और सूचित करें सभी () को केवल सिंक्रनाइज़ किए गए कोड से ही कॉल किया जाना चाहिए।

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

यहां हमारे पास सबसे लोकप्रिय उदाहरणों में से एक है जो दिखाता है कि विधि कैसे काम करती है। मान लीजिए कि हमारे पास एक स्टोर, एक निर्माता और एक उपभोक्ता है। निर्माता उत्पादन के कुछ उत्पादों को स्टोर में स्थानांतरित करता है, जिसके बाद उपभोक्ता उन्हें ले सकता है। मान लीजिए निर्माता को क्रमशः 8 वस्तुओं का उत्पादन करना है, उपभोक्ता को उन सभी को खरीदना होगा। लेकिन साथ ही, गोदाम में एक ही समय में 6 से अधिक आइटम नहीं हो सकते हैं। इस समस्या को हल करने के लिए, हम प्रतीक्षा () और सूचना () विधियों का उपयोग करते हैं। आइए तीन वर्गों को परिभाषित करें: बाजार , निर्माता और ग्राहक । रन () पद्धति में निर्माता इसके उपयोग से मार्केट ऑब्जेक्ट में 8 उत्पाद जोड़ता हैपुट () विधि। लूप में रन () विधि में क्लाइंट इन उत्पादों को प्राप्त करने के लिए मार्केट ऑब्जेक्ट की गेट विधि को कॉल करता है। मार्केट क्लास के पुट और प्राप्त करने के तरीकों को सिंक्रोनाइज़ किया जाता है। मार्केट क्लास में माल की उपस्थिति को ट्रैक करने के लिए , हम आइटम वेरिएबल के मान की जांच करते हैं। उत्पाद प्राप्त करने के लिए प्राप्त () विधि केवल तभी सक्रिय होनी चाहिए जब कम से कम एक उत्पाद हो । इसलिए, प्राप्त विधि में, हम जांचते हैं कि उत्पाद गायब है या नहीं। यदि आइटम उपलब्ध नहीं है, तो प्रतीक्षा () विधि को कहा जाता है। यह मेथड मार्केट ऑब्जेक्ट के मॉनिटर को रिलीज़ करता है और नोटिफिकेशन () तक गेट मेथड को ब्लॉक करता है।विधि को उसी मॉनीटर पर कॉल किया जाता है। जब कोई आइटम पुट () विधि में जोड़ा जाता है और सूचित () कहा जाता है, तो प्राप्त () विधि मॉनिटर प्राप्त करती है। उसके बाद, हमारे ग्राहक को एक आइटम प्राप्त होता है। ऐसा करने के लिए, एक संदेश प्रदर्शित होता है, और आइटम का मान घटाया जाता है। अंत में, सूचित करें () विधि कॉल जारी रखने के लिए पुट () विधि को संकेत देती है। पुट () विधि में , समान तर्क काम करता है, केवल अब पुट () विधि को काम करना चाहिए यदि बाजार में 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();
   }
}

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