Thread.sleep() Method sa Java

Sa mga Java program, may mga sitwasyon kung kailan masyadong mabilis ang pag-execute ng thread o kailangang lumipat ang program sa isa pang thread. Upang gawin ito, kailangan mong suspindihin ang pagpapatupad ng kasalukuyang thread. Sa Java, maaari itong gawin gamit ang java.lang.Thread.sleep() na pamamaraan.

Thread.sleep() method

Ang Thread class ay nasa Java.lang package at naglalaman ng Thread.sleep() method. Ang Java.lang.thread sleep() na pamamaraan ay ginagamit upang suspindihin ang kasalukuyang thread para sa isang tinukoy na tagal ng oras sa millisecond. Kung titingnan mo ang Oracle docs , makikita mo na mayroong dalawang overloaded sleep() na pamamaraan ng Thread class.

static void sleep(long millis)

kung saan ang millis ay ang oras sa millisecond. Ang pamamaraang ito ay nagiging sanhi ng pag-sleep ng kasalukuyang gumaganang thread (pansamantalang ihinto ang pagpapatupad, "pagtulog") para sa millis ng millisecond, depende sa katumpakan ng mga timer at scheduler ng system. Ang halaga ng argument para sa mga millisecond ay hindi maaaring negatibo. Kung gayon, ang IllegalArgumentException ay itatapon.

static void sleep(long millis, int nanos)

kung saan ang oras sa millisecond at nanos ay ang oras sa nanosecond. Ang variant ng paraan na ito ay ginagamit upang suspindihin ang pagpapatupad ng kasalukuyang thread para sa eksaktong oras sa millisecond at nanosecond. Ang halaga ng nanosecond ay may bisa sa pagitan ng 0 at 999999. Gumawa tayo ng isang simpleng program na gumagamit ng Thread.sleep() na paraan upang i-pause ang pagpapatupad ng pangunahing thread sa loob ng 5 segundo:

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

Ano ang nangyayari sa programang ito? Una itong magsisimula, pagkatapos ay natutulog ito ng 5 millisecond (5 segundo), pagkatapos ay magpi-print sa console ng mensahe tungkol sa kung gaano ito katagal na-freeze, at pagkatapos ay lalabas. Ang output ay: Tulad ng nakikita mo, ang programa ay hindi huminto sa loob ng 5 segundo, ngunit medyo mas mahaba. Gayundin kung patakbuhin mo ang program sa iyong computer, mapapansin mo na maaari nitong ihinto ang pagpapatupad ng thread nang mas mahaba sa 5000 millisecond at hindi kinakailangan para sa 5008 milliseconds. Ang punto ay ang lahat ay nakasalalay sa operating system at ang tiyak na pagpapatupad ng thread scheduler. Sa kaunting detalye, ang aktwal na oras na naghihintay ang isang thread bago magising at simulan ang pagpapatupad ay depende sa mga timer at scheduler ng system. Para sa isang tahimik na system, ang aktwal na oras ng pagtulog ay malapit sa tinukoy na oras ng pagtulog, ngunit para sa isang naka-load na system ay bahagyang mas mahaba ito. Ang pamamaraang ito ay kadalasang ginagamit sa mga thread ng bata kapag kailangan mong gumawa ng ilang aksyon sa lahat ng oras, ngunit hindi masyadong madalas. Narito ang isang halimbawa ng isang programa na magpi-print ng mensahe bawat segundo at hindi lalabas:

public class SleepDemo1 {

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

Mahahalagang punto ng Java Thread Sleep

Mahalagang tandaan na ang pamamaraan ng Java Thread Sleep ay gumagana sa paraang:

• Palagi nitong sinuspinde ang pagpapatupad ng kasalukuyang thread.

• Natutulog ang aktwal na thread hanggang sa magising ito, at ang oras ng pagpapatupad ay depende sa mga timer at scheduler ng system.

• Hindi hinaharangan ng natutulog na thread ang kasalukuyang thread.

• Anumang iba pang thread ay maaaring makagambala sa kasalukuyang natutulog na thread, kung saan ang isang InterruptedException ay itinapon.

• Ang halaga ng argumento para sa mga millisecond ay hindi maaaring negatibo, kung hindi, isang IllegalArgumentException ang itatapon.

Upang magbigay ng halimbawa ng paghahagis ng IllegalArgumentException , baguhin lang ng kaunti ang programa sa itaas:

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

Narito ang output: Sa itaas namin ilagay ang pangunahing thread sa pagtulog. Ngayon subukan nating ilapat ang pamamaraan sa ibang 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();
       }
}

Ang output ay: