Pausas em um programa

1.Thread.sleep()

Você pode inserir pausas na execução de um programa Java. Isso geralmente não é necessário, pois os usuários desejam que seus programas sejam executados o mais rápido possível. Poucas pessoas ficariam felizes se você desacelerasse seu código deliberadamente.

Mas, como programador, pode haver inúmeras situações em que uma pausa no seu código será útil. Por exemplo, suponha que você esteja escrevendo um jogo e deseja que ele faça algo uma vez a cada dois segundos ou várias vezes por segundo.

Basicamente, as pausas são úteis, então vamos ver como adicionar uma pausa ao seu código. Na verdade é muito simples:

Thread.sleep(duration);

Onde duration é a duração da pausa em milissegundos ( 1/1000de um segundo).

Esta instrução pausará seu programa por duration milissegundos. Exemplos:

Thread.sleep(2000);

Thread.sleep(500);

Thread.sleep(60 * 60 * 1000);

Veja como isso pode ser usado na prática. Digamos que estamos escrevendo um programa que lançará uma nave espacial. É assim que o código pode parecer:

for (int i = 10; i > 0; i--)
{
   System.out.println(i);
   Thread.sleep(1000);
}

System.out.println("Let's go!");

2. Calculando uma pausa corretamente

A duração da pausa é fácil de calcular. Se você precisar que o programa faça algo uma vez por segundo, a pausa será de 1000 ms. Se 2 vezes por segundo, faça uma pausa de 500ms (1000/2).

Se precisar fazer algo 15 vezes por segundo, faça uma pausa de 66 ms (1000/15). Tudo parece bastante simples:

The duration of one iteration of the loop = 1000 / number of times per second

Mas há uma nuance muito importante aqui. Embora muitas instruções sejam executadas muito rapidamente, elas não são instantâneas.

Veja isso. Digamos que você tenha uma ação que leva 100ms para ser concluída. Você deseja executar esta ação 5 vezes por segundo. Quanto tempo você deve fazer uma pausa? Definitivamente não é 200ms.

Para que a ação seja executada 5 vezes por segundo, precisamos que o tempo necessário para executar a ação mais a duração da pausa seja igual a 200 ms. Se fizermos isso, ele será executado exatamente 5 vezes por segundo. No nosso caso, a ação requer 100 ms, o que significa que ainda restam 100 ms para a pausa.

pause duration = duration of one iteration of the loop - time required to execute the action

Os desenvolvedores de jogos estão bem cientes do fato de que o tempo necessário para executar uma ação é muito maior que zero. E também as pessoas que jogam.

Se um jogo for executado a 20 FPS, isso significa que ele pode desenhar apenas 20 quadros na tela em um segundo. 1000/20produz 50 ms. Este é o tempo necessário para desenhar um quadro durante o jogo.

3. Nanossegundos

Os computadores hoje são muito mais rápidos do que quando o Java foi criado. Isso significa que uma pausa de 1 milissegundo pode não ser suficientemente granular.

Suponha que tenhamos uma ação superbreve que queremos executar 2.000 vezes por segundo. Como fazemos uma pausa de meio milissegundo?

Para isso, existe mais uma variante do Thread.sleep()método:

Thread.sleep(milliseconds, nanoseconds);

Esse método coloca o programa em hibernação pela quantidade especificada de milissegundos e nanossegundos.

Nanossegundos são 1 milionésimo de milissegundo. Isso significa que uma pausa de um milissegundo e meio ficaria assim:

Thread.sleep(1, 500_000);

E se você quiser uma pausa de 1/10um milissegundo, você precisa escrever isto:

Thread.sleep(0, 100_000);

Você pode não estar usando este método em seus programas agora. Mas é melhor saber e não usar do que precisar e não saber.

4. TimeUnitclasse

A propósito, o Java tem outra classe que facilitará sua vida se você decidir desacelerar seu aplicativo. Estamos falando sobre a TimeUnitclasse no java.util.concurrentpacote.

Lembre-se de que, como a classe não está no java.langpacote, você precisa adicionar a linha import java.util.concurrent.TimeUnit;ou escrever java.util.concurrent.TimeUnitcada vez em seu código.

Esta classe faz a mesma coisa que Thread.sleep(), mas é mais conveniente:

TimeUnit.HOURS.sleep(15)

Este código colocará seu programa em hibernação por 15 horas. Minutos, segundos, dias também estão disponíveis. Bem como microssegundos (1/1.000.000) e nanossegundos (1/1.000.000.000).

A TimeUnit classe tem as seguintes propriedades:

• nanossegundos:NANOSECONDS
• microssegundos:MICROSECONDS
• milissegundos:MILLISECONDS
• segundosSECONDS
• minutos:MINUTES
• horas:HOURS
• dias:DAYS

Trabalhar com essas propriedades é super conveniente, pois não há necessidade de pensar em converter, digamos, horas em milissegundos. Esse código é muito mais agradável de escrever e ler.

Mais detalhes podem ser lidos aqui .