జావాలో Thread.sleep() విధానం

జావా ప్రోగ్రామ్‌లలో, థ్రెడ్ చాలా వేగంగా అమలవుతున్నప్పుడు లేదా ప్రోగ్రామ్ మరొక థ్రెడ్‌కు మారాల్సిన సందర్భాలు ఉన్నాయి. దీన్ని చేయడానికి, మీరు ప్రస్తుత థ్రెడ్ యొక్క అమలును సస్పెండ్ చేయాలి. జావాలో, ఇది java.lang.Thread.sleep() పద్ధతిని ఉపయోగించి చేయవచ్చు .

Thread.sleep() పద్ధతి

థ్రెడ్ క్లాస్ Java.lang ప్యాకేజీలో ఉంది మరియు Thread.sleep() పద్ధతిని కలిగి ఉంటుంది . Java.lang.thread sleep() పద్ధతిని మిల్లీసెకన్లలో పేర్కొన్న సమయానికి ప్రస్తుత థ్రెడ్‌ని నిలిపివేయడానికి ఉపయోగించబడుతుంది. మీరు ఒరాకిల్ డాక్స్‌ని చూస్తే , థ్రెడ్ క్లాస్‌లో రెండు ఓవర్‌లోడ్డ్ స్లీప్() పద్ధతులు ఉన్నాయని మీరు కనుగొంటారు .

static void sleep(long millis)

ఇక్కడ మిల్లీస్ అనేది మిల్లీసెకన్లలో సమయం. ఈ పద్ధతి సిస్టమ్ టైమర్‌లు మరియు షెడ్యూలర్‌ల ఖచ్చితత్వాన్ని బట్టి మిల్లీసెకన్‌ల కోసం ప్రస్తుతం అమలు చేస్తున్న థ్రెడ్‌ను నిద్రపోయేలా చేస్తుంది (తాత్కాలికంగా అమలును ఆపండి, "స్లీపింగ్"). మిల్లీసెకన్ల ఆర్గ్యుమెంట్ విలువ ప్రతికూలంగా ఉండకూడదు. అలా అయితే, IllegalArgumentException విసిరివేయబడుతుంది.

static void sleep(long millis, int nanos)

ఇక్కడ మిల్లులు సమయం మిల్లీసెకన్లలో మరియు నానోలు అంటే నానోసెకన్లలో సమయం. మిల్లీసెకన్లు మరియు నానోసెకన్లలో ఖచ్చితమైన సమయానికి ప్రస్తుత థ్రెడ్ యొక్క అమలును నిలిపివేయడానికి ఈ పద్ధతి యొక్క రూపాంతరం ఉపయోగించబడుతుంది. నానోసెకండ్ విలువ 0 మరియు 999999 మధ్య చెల్లుతుంది . ప్రధాన థ్రెడ్ యొక్క అమలును 5 సెకన్ల పాటు పాజ్ చేయడానికి Thread.sleep() పద్ధతిని ఉపయోగించే ఒక సాధారణ ప్రోగ్రామ్‌ని క్రియేట్ చేద్దాం :

public class SleepDemo {

       public static void main(String[] args) throws InterruptedException {
           //the current time in milliseconds
           long start = System.currentTimeMillis();
           // stop the main thread of the program for 5000 milliseconds (5 seconds)
           Thread.sleep(5000);
           System.out.println("The thread is paused for " + (System.currentTimeMillis() - start) + " milliseconds");
       }
}

ఈ కార్యక్రమంలో ఏం జరుగుతోంది? మొదట ఇది ప్రారంభమవుతుంది, తర్వాత అది 5 మిల్లీసెకన్లు (5 సెకన్లు) నిద్రపోతోంది, ఆపై ఎంతసేపు స్తంభింపజేయబడిందనే సందేశాన్ని కన్సోల్‌కి ప్రింట్ చేసి, ఆపై నిష్క్రమిస్తుంది. అవుట్‌పుట్: మీరు చూడగలిగినట్లుగా, ప్రోగ్రామ్ 5 సెకన్ల పాటు పాజ్ చేయలేదు, కానీ కొంచెం ఎక్కువ. మీరు మీ కంప్యూటర్‌లో ప్రోగ్రామ్‌ను అమలు చేస్తే, అది 5000 మిల్లీసెకన్ల కంటే ఎక్కువ కాలం పాటు థ్రెడ్ అమలును ఆపివేయవచ్చని మరియు 5008 మిల్లీసెకన్లకు అవసరం లేదని మీరు గమనించవచ్చు. పాయింట్ ఇది అన్ని ఆపరేటింగ్ సిస్టమ్ మరియు థ్రెడ్ షెడ్యూలర్ యొక్క నిర్దిష్ట అమలుపై ఆధారపడి ఉంటుంది. మరికొంత వివరంగా చెప్పాలంటే, థ్రెడ్ నిద్రలేవడానికి మరియు అమలును ప్రారంభించడానికి ముందు వేచి ఉండే అసలు సమయం సిస్టమ్ టైమర్‌లు మరియు షెడ్యూలర్‌లపై ఆధారపడి ఉంటుంది. నిశ్శబ్ద వ్యవస్థ కోసం, అసలు నిద్ర సమయం పేర్కొన్న నిద్ర సమయానికి దగ్గరగా ఉంటుంది, కానీ లోడ్ చేయబడిన సిస్టమ్‌కు ఇది కొంచెం ఎక్కువ ఉంటుంది. ఈ పద్ధతి తరచుగా చైల్డ్ థ్రెడ్‌లలో ఉపయోగించబడుతుంది, మీరు ఎప్పుడైనా కొన్ని చర్యలు చేయవలసి ఉంటుంది, కానీ చాలా తరచుగా కాదు. ప్రతి సెకనుకు సందేశాన్ని ముద్రించే మరియు ఎప్పటికీ నిష్క్రమించే ప్రోగ్రామ్ యొక్క ఉదాహరణ ఇక్కడ ఉంది:

public class SleepDemo1 {

   public static void main(String[] args) throws InterruptedException {
       while (true)
       {
           Thread.sleep(1000);
           System.out.println("One more second");
       }
   }
}

జావా థ్రెడ్ స్లీప్ యొక్క ముఖ్యమైన పాయింట్లు

జావా థ్రెడ్ స్లీప్ పద్ధతి ఈ విధంగా పనిచేస్తుందని గుర్తుంచుకోవడం ముఖ్యం :

• ఇది ఎల్లప్పుడూ ప్రస్తుత థ్రెడ్ యొక్క అమలును సస్పెండ్ చేస్తుంది.

• అసలు థ్రెడ్ మేల్కొనే వరకు నిద్రిస్తుంది మరియు అమలు సమయం సిస్టమ్ టైమర్‌లు మరియు షెడ్యూలర్‌లపై ఆధారపడి ఉంటుంది.

• స్లీపింగ్ థ్రెడ్ ప్రస్తుత థ్రెడ్‌ను నిరోధించదు.

• ఏదైనా ఇతర థ్రెడ్ ప్రస్తుత స్లీపింగ్ థ్రెడ్‌కు అంతరాయం కలిగించవచ్చు, ఈ సందర్భంలో అంతరాయ మినహాయింపు విసిరివేయబడుతుంది.

• మిల్లీసెకన్ల ఆర్గ్యుమెంట్ విలువ ప్రతికూలంగా ఉండకూడదు, లేకుంటే చట్టవిరుద్ధమైన ఆర్గ్యుమెంట్ మినహాయింపు విసిరివేయబడుతుంది.

ఇల్లీగల్ ఆర్గ్యుమెంట్ ఎక్సెప్షన్ విసిరే ఉదాహరణ ఇవ్వడానికి , పై ప్రోగ్రామ్‌ను కొంచెం సవరించండి:

public class SleepDemo1 {

       public static void main(String[] args) throws InterruptedException {
           //the current time in milliseconds
           long start = System.currentTimeMillis();
           // stop the main thread of the program for 5000 milliseconds (5 seconds)
           Thread.sleep(-5000);
           System.out.println("The thread is paused for " + (System.currentTimeMillis() - start) + " ms");
       }
}

ఇక్కడ అవుట్‌పుట్ ఉంది: పైన మేము నిద్రపోవడానికి ప్రధాన థ్రెడ్ని ఉంచాము. ఇప్పుడు ఈ పద్ధతిని కొన్ని ఇతర థ్రెడ్‌లకు వర్తింపజేయడానికి ప్రయత్నిద్దాం.

// Java Program to sleep the custom thread
public class SleepDemo2 extends Thread{

       public void run()
       {
           // thread 0
           try {
               for (int i = 0; i < 10; i++) {

                   // sleeps the main thread for about 2 seconds
                   Thread.sleep(2000);
                   System.out.println(i);
               }
           }
           catch (Exception e) {

               // catching the exception
               System.out.println(e);
           }
       }
       public static void main(String[] args)
       {
           SleepDemo2 sleepDemo2 = new SleepDemo2();
           sleepDemo2.start();
       }
}

అవుట్‌పుట్: