Thread.sleep() metódus Java nyelven

Java programokban vannak olyan helyzetek, amikor egy szál túl gyorsan fut, vagy a programnak át kell váltania egy másik szálra. Ehhez fel kell függesztenie az aktuális szál végrehajtását. Java nyelven ezt a java.lang.Thread.sleep() metódussal lehet megtenni .

Thread.sleep() metódus

A Thread osztály a Java.lang csomagban található, és tartalmazza a Thread.sleep() metódust. A Java.lang.thread sleep() metódus az aktuális szál felfüggesztésére szolgál ezredmásodpercben megadott ideig. Ha megnézi az Oracle docs -ot , azt találja, hogy a Thread osztály két túlterhelt sleep() metódusa van .

static void sleep(long millis)

ahol millis az idő ezredmásodpercben. Ez a módszer az éppen futó szálat alvó állapotba helyezi (ideiglenesen leállítja a végrehajtást, „alszik”) ezredmásodpercekre, a rendszeridőzítők és ütemezők pontosságától függően. Az ezredmásodperc argumentumértéke nem lehet negatív. Ha igen, akkor az IllegalArgumentException ki lesz dobva.

static void sleep(long millis, int nanos)

ahol mills it az idő ezredmásodpercben, nanos pedig az idő nanoszekundumban. A módszer ezen változata az aktuális szál végrehajtásának felfüggesztésére szolgál ezredmásodpercekben és nanoszekundumokban megadott pontos időre. A nanoszekundumos érték 0 és 999999 között érvényes. Készítsünk egy egyszerű programot, amely a Thread.sleep() metódussal szünetelteti a főszál végrehajtását 5 másodpercre:

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

Mi történik ebben a programban? Először elindul, majd 5 ezredmásodpercig (5 másodpercig) alszik, majd kiír egy üzenetet a konzolra arról, hogy mennyi ideig volt lefagyva, majd kilép. A kimenet a következő: Mint látható, a program nem 5 másodpercre állt meg, hanem egy kicsit tovább. Ha futtatja a programot a számítógépén, akkor észre fogja venni, hogy 5000 ezredmásodpercnél hosszabb ideig leállíthatja a szál végrehajtását, és 5008 ezredmásodpercig nem szükséges. A lényeg az, hogy minden az operációs rendszertől és a szálütemező konkrét megvalósításától függ. Kicsit részletesebben, a tényleges idő, amennyi egy szál várakozása előtt felébred és a végrehajtás megkezdése előtt a rendszer időzítőitől és ütemezőitől függ. Csendes rendszer esetén a tényleges alvásidő közel van a megadott alvásidőhöz, de egy terhelt rendszernél valamivel hosszabb lesz. Ezt a módszert gyakran használják gyermekszálakban, amikor folyamatosan, de nem túl gyakran kell valamilyen műveletet végrehajtania. Íme egy példa egy olyan programra, amely másodpercenként nyomtat egy üzenetet, és soha nem lép ki:

public class SleepDemo1 {

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

A Java Thread Sleep fontos pontjai

Fontos megjegyezni, hogy a Java Thread Sleep módszer a következőképpen működik:

• Mindig felfüggeszti az aktuális szál végrehajtását.

• A tényleges szál addig alszik, amíg felébred, és a végrehajtási idő a rendszer időzítőitől és ütemezőitől függ.

• Az alvó szál nem blokkolja az aktuális szálat.

• Bármely más szál megszakíthatja az aktuális alvó szálat, ebben az esetben egy InterruptedException jelenik meg.

• Az ezredmásodpercekhez tartozó argumentumérték nem lehet negatív, különben a rendszer egy IllegalArgumentException-t dob ​​fel.

Ha példát szeretne adni egy IllegalArgumentException dobására , csak módosítsa egy kicsit a fenti programot:

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

Íme a kimenet: Fent a főszálat elaltatjuk. Most próbáljuk meg alkalmazni a módszert egy másik szálra.

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

A kimenet a következő: