Thread.sleep() Methode in Java

In Java-programma's zijn er situaties waarin een thread te snel wordt uitgevoerd of het programma moet overschakelen naar een andere thread. Om dit te doen, moet u de uitvoering van de huidige thread opschorten. In Java kan dit worden gedaan met de methode java.lang.Thread.sleep() .

Thread.sleep() methode

De klasse Thread is aanwezig in het Java.lang-pakket en bevat de methode Thread.sleep() . De methode Java.lang.thread sleep() wordt gebruikt om de huidige thread gedurende een bepaalde tijd in milliseconden op te schorten. Als u naar Oracle docs kijkt , ziet u dat er twee overbelaste sleep()- methoden van de Thread- klasse zijn.

static void sleep(long millis)

waarbij millis de tijd in milliseconden is. Deze methode zorgt ervoor dat de momenteel uitgevoerde thread slaapt (uitvoering tijdelijk stopt, "slaapt") gedurende millis van milliseconden, afhankelijk van de precisie van de systeemtimers en planners. De argumentwaarde voor milliseconden kan niet negatief zijn. Als dit het geval is, wordt de IllegalArgumentException gegenereerd.

static void sleep(long millis, int nanos)

waar maalt het de tijd in milliseconden en nanos is de tijd in nanoseconden. Deze variant van de methode wordt gebruikt om de uitvoering van de huidige thread op te schorten voor de exacte tijd in milliseconden en nanoseconden. De waarde van de nanoseconde is geldig tussen 0 en 999999. Laten we een eenvoudig programma maken dat de methode Thread.sleep() gebruikt om de uitvoering van de hoofdthread gedurende 5 seconden te onderbreken:

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

Wat gebeurt er in dit programma? Eerst start het, dan slaapt het gedurende 5 milliseconden (5 seconden), drukt dan een bericht af naar de console over hoe lang het bevroren was, en sluit dan af. De uitvoer is: Zoals je kunt zien, pauzeerde het programma niet 5 seconden, maar iets langer. Ook als u het programma op uw computer uitvoert, zult u merken dat het de uitvoering van de thread langer dan 5000 milliseconden kan stoppen en niet nodig is voor 5008 milliseconden. Het punt is dat het allemaal afhangt van het besturingssysteem en de specifieke implementatie van de threadplanner. In een beetje meer detail, de werkelijke tijd die een thread wacht voordat hij wakker wordt en de uitvoering start, hangt af van de systeemtimers en planners. Voor een stil systeem ligt de werkelijke slaaptijd dicht bij de gespecificeerde slaaptijd, maar voor een belast systeem zal deze iets langer zijn. Deze methode wordt vaak gebruikt in kinderthreads wanneer u de hele tijd iets moet doen, maar niet te vaak. Hier is een voorbeeld van een programma dat elke seconde een bericht afdrukt en nooit afsluit:

public class SleepDemo1 {

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

Belangrijke punten van Java Thread Sleep

Het is belangrijk om te onthouden dat de Java Thread Sleep -methode zo werkt dat:

• Het schort altijd de uitvoering van de huidige thread op.

• De eigenlijke thread slaapt totdat hij wakker wordt en de uitvoeringstijd is afhankelijk van de systeemtimers en planners.

• De slapende draad blokkeert de huidige draad niet.

• Elke andere thread kan de huidige slapende thread onderbreken, in welk geval een InterruptedException wordt gegenereerd.

• De argumentwaarde voor milliseconden kan niet negatief zijn, anders wordt er een IllegalArgumentException gegenereerd.

Om een ​​voorbeeld te geven van het gooien van een IllegalArgumentException , past u het bovenstaande programma een beetje aan:

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

Hier is de uitvoer: Hierboven zetten we de rode draad in slaap. Laten we nu proberen de methode toe te passen op een andere thread.

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

De uitvoer is: