ஜாவாவில் த்ரெட்.ஸ்லீப்() முறை

ஜாவா நிரல்களில், ஒரு நூல் மிக வேகமாக இயங்கும் சூழ்நிலைகள் உள்ளன அல்லது நிரல் மற்றொரு தொடருக்கு மாற வேண்டும். இதைச் செய்ய, தற்போதைய நூலின் செயல்பாட்டை நீங்கள் இடைநிறுத்த வேண்டும். ஜாவாவில், 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");
       }
   }
}

ஜாவா த்ரெட் ஸ்லீப்பின் முக்கிய புள்ளிகள்

ஜாவா த்ரெட் ஸ்லீப் முறை பின்வரும் வழியில் செயல்படுகிறது என்பதை நினைவில் கொள்வது அவசியம் :

• இது எப்பொழுதும் தற்போதைய நூலை செயல்படுத்துவதை இடைநிறுத்துகிறது.

• உண்மையான நூல் எழுந்திருக்கும் வரை தூங்குகிறது, மேலும் செயல்படுத்தும் நேரம் கணினி டைமர்கள் மற்றும் திட்டமிடுபவர்களைப் பொறுத்தது.

• ஸ்லீப்பிங் த்ரெட் தற்போதைய நூலைத் தடுக்காது.

• வேறு எந்த நூலும் தற்போதைய ஸ்லீப்பிங் த்ரெட்டில் குறுக்கிடலாம், இதில் ஒரு InterruptedException எறியப்படும்.

• மில்லி விநாடிகளுக்கான வாத மதிப்பு எதிர்மறையாக இருக்கக்கூடாது, இல்லையெனில் ஒரு சட்டவிரோத ஆர்குமென்ட்எக்செப்ஷன் வீசப்படும்.

ஒரு IllegalArgumentException ஐ எறிவதற்கான உதாரணத்தைக் கொடுக்க , மேலே உள்ள நிரலை சிறிது மாற்றவும்:

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();
       }
}

வெளியீடு: