జావాలో వెయిట్() పద్ధతి

ఈ కథనంలో, మేము థ్రెడ్‌ను నియంత్రించడానికి వేచి ఉండే () పద్ధతిని మరియు notify() / notifyAll() పద్ధతులను పరిశీలిస్తాము . ఈ పద్ధతులు బేస్ క్లాస్ java.lang.Object లో నిర్వచించబడ్డాయి మరియు తదనుగుణంగా, జావాలో ఉన్న వారసత్వ మెకానిజమ్‌లు ఖచ్చితంగా అన్ని తరగతులకు ఈ పద్ధతులను అందిస్తాయి. అంటే, మీరు మీ స్వంత తరగతి మరియు దాని వస్తువులను సృష్టించినప్పుడు, మీరు ఎల్లప్పుడూ ఈ పద్ధతులను కాల్ చేయవచ్చు.

వేచి() మరియు నోటిఫై()/notifyAll() పద్ధతులు ఎలా పని చేస్తాయి?

• వేచి ఉండండి () . సంక్షిప్తంగా, ఈ పద్ధతి మానిటర్‌ను విడుదల చేస్తుంది మరియు మరొక థ్రెడ్ నోటిఫికేషన్() / notifyAll() పద్ధతికి కాల్ చేసే వరకు కాలింగ్ థ్రెడ్‌ను వేచి ఉండే స్థితిలో ఉంచుతుంది ;
• తెలియజేయి() . నిరీక్షణ() పద్ధతిని గతంలో పిలిచే థ్రెడ్ యొక్క పనిని కొనసాగిస్తుంది;
• notifyAll() పద్ధతి మునుపు వేచి ఉండే() పద్ధతిని కలిగి ఉన్న అన్ని థ్రెడ్‌లను పునఃప్రారంభిస్తుంది .

ఇప్పుడు వేచి () పద్ధతిని నిశితంగా పరిశీలిద్దాం . ఆబ్జెక్ట్ క్లాస్ ఈ పద్ధతికి మూడు ఎంపికలను కలిగి ఉంది :

• పబ్లిక్ ఆఖరి స్థానిక శూన్య నిరీక్షణ (దీర్ఘ సమయం ముగిసింది మిల్లిస్) అంతరాయ మినహాయింపులను విసిరివేస్తుంది ; ఇది ప్రస్తుత థ్రెడ్ మేల్కొనే వరకు వేచి ఉండేలా చేస్తుంది. సాధారణంగా ఇది తెలియజేయబడటం లేదా అంతరాయం కలిగించడం ద్వారా లేదా కొంత నిజ సమయం గడిచే వరకు జరుగుతుంది.

• పబ్లిక్ ఆఖరి శూన్య నిరీక్షణ() అంతరాయ మినహాయింపులను విసిరివేస్తుంది . పారామితులు లేని పద్ధతిని మనం రెండవదిగా రాసుకోవడం యాదృచ్చికం కాదు. వాస్తవానికి, మీరు దాని కోడ్‌ను చూస్తే, ఇది పద్ధతి యొక్క మొదటి రూపాంతరాన్ని సూచిస్తుంది, ఇది కేవలం 0L ఆర్గ్యుమెంట్‌ను కలిగి ఉంటుంది.

• పబ్లిక్ ఫైనల్ నిరీక్షణ (దీర్ఘ సమయం ముగిసింది, పూర్ణాంక నానోలు) . ప్రస్తుత థ్రెడ్ మేల్కొనే వరకు, సాధారణంగా తెలియజేయడం లేదా అంతరాయం కలిగించడం ద్వారా లేదా కొంత నిజ సమయం గడిచే వరకు వేచి ఉండేలా చేస్తుంది.

వెయిట్ () పద్ధతి కాలింగ్ థ్రెడ్‌ను సస్పెండ్ చేయడానికి ఉద్దేశించబడింది. దాని అర్థం ఏమిటి? ఈ పద్ధతులు తరగతికి చెందినవి. తరగతి ఆధారంగా, మీరు ఒక వస్తువును సృష్టిస్తారు. కొన్ని థ్రెడ్‌లలో వస్తువులు ఉన్నాయి. అంటే కొన్ని థ్రెడ్లలో వస్తువులు సృష్టించబడతాయి. ఈ ఆబ్జెక్ట్ పనిచేసే థ్రెడ్‌లో, మీరు వెయిట్ () అని పిలిస్తే , ఈ థ్రెడ్ ఆగిపోతుందనే వాస్తవానికి ఇది దారి తీస్తుంది. వస్తువు కూడా ఒక రకమైన మానిటర్‌గా పనిచేస్తుంది. ఇది ఏమిటి? మీరు వేర్వేరు వస్తువులను సృష్టించగలరని మరియు అవన్నీ వేచి ఉండగలవని స్పష్టంగా ఉంది ()పద్ధతి. ఒక నిర్దిష్ట థ్రెడ్ ఆగిపోవడానికి ఏ వస్తువు కారణమైందో అర్థం చేసుకోవచ్చు. థ్రెడ్ ఆగిపోతుంది మరియు పారామీటర్‌లో వ్రాసినంత కాలం వేచి ఉంటుంది. ఆపై అది ప్రారంభమవుతుంది. ఈ థ్రెడ్ స్వయంగా ప్రారంభించబడదు. పనిని తిరిగి ప్రారంభించడానికి, అన్ని పద్ధతులకు తెలియజేయి మరియు తెలియజేయండి. నోటిఫై() లేదా నోటిఫైఅల్() కి సంబంధించిన కాల్ ఏదైనా ఇతర థ్రెడ్‌ని ప్లే చేయాలి. వెయిట్() తో , మీరు బహుళ థ్రెడ్‌లను ఆపివేయవచ్చు మరియు అన్ని థ్రెడ్‌లను notifyAll() తో ప్రారంభించవచ్చు . బహుళ థ్రెడ్‌లు ఆపివేయబడి, నోటిఫై() అని పిలిస్తే, ఈ పద్ధతిని ఏ థ్రెడ్ మళ్లీ ప్రారంభిస్తుందో ఖచ్చితంగా చెప్పడం అసాధ్యం. వెయిట్() పద్ధతిలో వెయిటింగ్ థ్రెడ్‌లు లేకుంటే , నోటిఫై() లేదా ఉన్నప్పుడు ఏమీ జరగదుnotifyAll() అంటారు. థ్రెడ్ ఒక నిర్దిష్ట వస్తువుపై ప్రస్తుతం లాక్‌ని కలిగి ఉన్నట్లయితే మాత్రమే వేచి ఉండే() లేదా నోటిఫై() పద్ధతులను కాల్ చేయగలదు. wait() , notify() , and notifyAll() సమకాలీకరించబడిన కోడ్ నుండి మాత్రమే కాల్ చేయబడాలి.

వేచి ఉండండి () పద్ధతి ఉదాహరణ

పద్ధతి ఎలా పని చేస్తుందో వివరించే అత్యంత ప్రజాదరణ పొందిన ఉదాహరణలలో ఒకటి ఇక్కడ మేము పొందాము. మనకు స్టోర్, నిర్మాత మరియు వినియోగదారు ఉన్నారని అనుకుందాం. తయారీదారు కొన్ని ఉత్పత్తి ఉత్పత్తులను దుకాణానికి బదిలీ చేస్తాడు, ఆ తర్వాత వినియోగదారు వాటిని తీసుకోవచ్చు. తయారీదారు వరుసగా 8 వస్తువులను ఉత్పత్తి చేయనివ్వండి, వినియోగదారు వాటన్నింటినీ కొనుగోలు చేయాలి. కానీ అదే సమయంలో, ఒకే సమయంలో 6 కంటే ఎక్కువ వస్తువులు గిడ్డంగిలో ఉండకూడదు. ఈ సమస్యను పరిష్కరించడానికి, మేము వేచి() మరియు నోటిఫై() పద్ధతులను ఉపయోగిస్తాము. మూడు తరగతులను నిర్వచిద్దాం: మార్కెట్ , తయారీదారు మరియు క్లయింట్ . రన్ () పద్ధతిలో తయారీదారు మార్కెట్ ఆబ్జెక్ట్‌ని ఉపయోగించి 8 ఉత్పత్తులను జోడిస్తుందిపుట్ () పద్ధతి. లూప్‌లోని రన్() పద్ధతిలోని క్లయింట్ ఈ ఉత్పత్తులను పొందడానికి మార్కెట్ ఆబ్జెక్ట్‌ని పొందే పద్ధతిని పిలుస్తుంది . మార్కెట్ క్లాస్ యొక్క పుట్ మరియు గెట్ పద్ధతులు సమకాలీకరించబడ్డాయి. మార్కెట్ క్లాస్‌లో వస్తువుల ఉనికిని ట్రాక్ చేయడానికి , మేము ఐటెమ్ వేరియబుల్ విలువను తనిఖీ చేస్తాము. ఒక ఉత్పత్తిని పొందడం కోసం get () పద్ధతి కనీసం ఒక ఉత్పత్తి ఉంటే మాత్రమే కాల్చాలి. అందువల్ల, పొందే పద్ధతిలో, ఉత్పత్తి తప్పిపోయిందో లేదో తనిఖీ చేస్తాము. అంశం అందుబాటులో లేకుంటే, వేచి() పద్ధతి అంటారు. ఈ పద్ధతి మార్కెట్ ఆబ్జెక్ట్ యొక్క మానిటర్‌ను విడుదల చేస్తుంది మరియు నోటిఫై() వరకు పొందే పద్ధతిని బ్లాక్ చేస్తుందిపద్ధతిని అదే మానిటర్‌లో పిలుస్తారు. పుట్() పద్ధతిలో ఐటెమ్‌ని జోడించి , నోటిఫై() అని పిలిచినప్పుడు, 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() పద్ధతిలో వెయిట్()ని ఉపయోగించి, తయారీదారు కొత్త అంశాన్ని జోడించడానికి మేము వేచి ఉన్నాము . మరియు జోడించిన తర్వాత, వేర్‌హౌస్‌లో ఒక స్థలం ఉచితం అని చెప్పడానికి మేము notify() అని పిలుస్తాము మరియు మీరు మరిన్ని జోడించవచ్చు. పుట్() పద్ధతిలో , వెయిట్()ని ఉపయోగించి , మేము వేర్‌హౌస్‌లో స్థలం విడుదల కోసం ఎదురు చూస్తున్నాము . ఖాళీ ఖాళీ అయిన తర్వాత, మేము ఐటెమ్‌ను జోడిస్తాము, నోటిఫై() థ్రెడ్‌ను ప్రారంభిస్తుంది మరియు క్లయింట్ వస్తువును తీసుకోవచ్చు. మా ప్రోగ్రామ్ యొక్క అవుట్‌పుట్ ఇక్కడ ఉంది: