Método Thread.sleep() em Java

Em programas Java, há situações em que um thread está executando muito rápido ou o programa precisa alternar para outro thread. Para fazer isso, você precisa suspender a execução do thread atual. Em Java, isso pode ser feito usando o método java.lang.Thread.sleep() .

Método Thread.sleep()

A classe Thread está presente no pacote Java.lang e contém o método Thread.sleep() . O método Java.lang.thread sleep() é usado para suspender o thread atual por um período de tempo especificado em milissegundos. Se você examinar os documentos do Oracle , descobrirá que há dois métodos sleep() sobrecarregados da classe Thread .

static void sleep(long millis)

onde milis é o tempo em milissegundos. Esse método faz com que o thread atualmente em execução entre em suspensão (interrompa temporariamente a execução, “dormindo”) por milissegundos, dependendo da precisão dos cronômetros e agendadores do sistema. O valor do argumento para milissegundos não pode ser negativo. Nesse caso, o IllegalArgumentException será lançado.

static void sleep(long millis, int nanos)

onde mills é o tempo em milissegundos e nanos é o tempo em nanossegundos. Essa variante do método é usada para suspender a execução do thread atual pelo tempo exato em milissegundos e nanossegundos. O valor de nanossegundos é válido entre 0 e 999999. Vamos criar um programa simples que usa o método Thread.sleep() para pausar a execução da thread principal por 5 segundos:

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

O que está acontecendo neste programa? Primeiro ele inicia, depois fica inativo por 5 milissegundos (5 segundos), depois imprime no console uma mensagem sobre quanto tempo ficou congelado e, em seguida, sai. A saída é: Como você pode ver, o programa não parou por 5 segundos, mas um pouco mais. Além disso, se você executar o programa em seu computador, notará que ele pode interromper a execução do thread por mais de 5.000 milissegundos e não é necessário por 5.008 milissegundos. A questão é que tudo depende do sistema operacional e da implementação específica do agendador de threads. Com um pouco mais de detalhes, o tempo real que um thread espera antes de acordar e iniciar a execução depende dos cronômetros e agendadores do sistema. Para um sistema silencioso, o tempo de inatividade real é próximo ao tempo de inatividade especificado, mas para um sistema carregado será um pouco mais longo. Esse método geralmente é usado em threads filhos quando você precisa executar alguma ação o tempo todo, mas não com muita frequência. Aqui está um exemplo de um programa que imprimirá uma mensagem a cada segundo e nunca sairá:

public class SleepDemo1 {

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

Pontos importantes do Java Thread Sleep

É importante lembrar que o método Java Thread Sleep funciona de forma que:

• Ele sempre suspende a execução do thread atual.

• O encadeamento real dorme até acordar e o tempo de execução depende dos cronômetros e agendadores do sistema.

• O thread adormecido não bloqueia o thread atual.

• Qualquer outro thread pode interromper o thread adormecido atual, caso em que uma InterruptedException é lançada.

• O valor do argumento para milissegundos não pode ser negativo, caso contrário, um IllegalArgumentException será lançado.

Para dar um exemplo de lançamento de IllegalArgumentException , basta modificar um pouco o programa acima:

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

Aqui está a saída: Acima, colocamos o fio principal para dormir. Agora vamos tentar aplicar o método a algum outro 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();
       }
}

A saída é: