Imprima "olá mundo" a cada X segundos

127

Ultimamente tenho usado loops com números grandes para imprimir Hello World:

int counter = 0;

while(true) {
    //loop for ~5 seconds
    for(int i = 0; i < 2147483647 ; i++) {
        //another loop because it's 2012 and PCs have gotten considerably faster :)
        for(int j = 0; j < 2147483647 ; j++){ ... }
    }
    System.out.println(counter + ". Hello World!");
    counter++;
}

Entendo que essa é uma maneira muito boba de fazer isso, mas eu nunca usei nenhuma biblioteca de timer em Java ainda. Como alguém modifica o item acima para imprimir a cada 3 segundos?

meiryo
fonte
1
Embora as respostas abaixo devam obviamente responder à sua pergunta, você também deve observar que o modo como está fazendo isso resultaria em um intervalo diferente em cada máquina. Depende de quão rápido ele pode executar o compilador.
IHazABone
Possível duplicata de Chamar uma função a cada 10 minutos
Alex.K.

Respostas:

187

Você também pode dar uma olhada Timere TimerTaskclasses que você pode usar para agendar sua tarefa para ser executada a cada nsegundos.

Você precisa de uma classe que estenda TimerTaske substitua o public void run()método, que será executada toda vez que você passar uma instância dessa classe para o timer.schedule()método

Aqui está um exemplo, que imprime a Hello Worldcada 5 segundos: -

class SayHello extends TimerTask {
    public void run() {
       System.out.println("Hello World!"); 
    }
}

// And From your main() method or any other method
Timer timer = new Timer();
timer.schedule(new SayHello(), 0, 5000);
Rohit Jain
fonte
9
Observe que o schedulemétodo 2-param será executado uma vez após o atraso especificado. O 3-param scheduleou scheduleAtFixedRateprecisaria ser usado.
Tim Bender
2
lol, sim. Às vezes, recebo votos positivos nas respostas e procuro descobrir que meu próprio entendimento melhorou desde a última vez em que confiei em fornecer uma solução.
Tim Bender
4
@ TimBender Apenas me perguntando se o OP realmente fez sua tarefa com isso;) De qualquer forma, agora eu preferiria usar ExecutorServicepara essas tarefas. Essa é realmente uma grande melhoria em relação à API de threads tradicional. Só não o usei no momento da resposta.
Rohit Jain
4
Timer timer = new Timer(true);deve ser definido truecomo um daemon. A menos que você queira que o timer ainda esteja em execução após o fechamento do aplicativo.
Tomasz Mularczyk
Isso me ajudou a finalmente me fazer entender os cronômetros também. + 1.Mantenha o bom trabalho!
Daniel Tork
197

Se você deseja executar uma tarefa periódica, use a ScheduledExecutorService. ScheduledExecutorService.scheduleAtFixedRate, especificamente

O código:

Runnable helloRunnable = new Runnable() {
    public void run() {
        System.out.println("Hello world");
    }
};

ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
executor.scheduleAtFixedRate(helloRunnable, 0, 3, TimeUnit.SECONDS);
Tim Bender
fonte
10
Espero que mais alguém vote isso também. Thread.sleep () pode se encaixar melhor no código do OP, mas é uma reinvenção bastante amador da roda. Engenheiros de software profissionais usarão API testada e confiável, como o TimerTask. O ScheduledExecutorService é ainda melhor; consulte a Concorrência Java na Prática de Brian Goetz et al . A última turma existe há quase uma década - é triste que todas essas outras respostas ignorem.
Michael Scheper
2
@ MichaelScheper, obrigado, fico feliz em ver que essa resposta finalmente superou a TimerTaskvariante. Curiosamente, notei que a resposta aceita não está correta: \ A idade das duas APIs à parte, ScheduledExecutorServiceé simplesmente mais intuitivamente declarativa. O uso de TimeUnitcomo parâmetro torna muito mais claro o que está ocorrendo. Longe vão os dias do código 5*60*1000 // 5 minutes.
Tim Bender
2
@ TimBender Notei que você tem um 3 para o argumento do período. Não consigo descobrir se isso é em segundos ou milissegundos. Eu gostaria que ele funcionasse a cada 500 milissegundos (meio segundo).
JohnMerlino
2
Ahh, entendi. O quarto argumento permite especificar o tempo, por exemplo, TimeUnit.MILLISECONDS.
JohnMerlino
1
@TerryCarter No Java8 + Em vez disso, você pode fazer o Runnable helloRunnable = () -> { /*code */ };que é ainda mais bonito;)
Joel
39

Tente fazer isso:

Timer t = new Timer();
t.schedule(new TimerTask() {
    @Override
    public void run() {
       System.out.println("Hello World");
    }
}, 0, 5000);

Esse código será executado no console do Hello World a cada 5000 milissegundos ( 5 segundos). Para obter mais informações, leia https://docs.oracle.com/javase/1.5.0/docs/api/java/util/Timer.html


fonte
16

Eu descobri com um temporizador, espero que ajude. Eu usei um timer de java.util.Timere TimerTaskdo mesmo pacote. Ver abaixo:

TimerTask task = new TimerTask() {

    @Override
    public void run() {
        System.out.println("Hello World");
    }
};

Timer timer = new Timer();
timer.schedule(task, new Date(), 3000);
tmwanik
fonte
10

Você pode usar Thread.sleep(3000)dentro do loop.

Nota: Isso exigirá um try/catchbloco.

saum22
fonte
6
public class HelloWorld extends TimerTask{

    public void run() {

        System.out.println("Hello World");
    }
}


public class PrintHelloWorld {
    public static void main(String[] args) {
        Timer timer = new Timer();
        timer.schedule(new HelloWorld(), 0, 5000);

        while (true) {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                System.out.println("InterruptedException Exception" + e.getMessage());
            }
        }
    }
}

loop infinito é criado A tarefa do agendador de anúncios é configurada.

Vicky
fonte
4

A maneira mais fácil seria definir o segmento principal para dormir 3000 milissegundos (3 segundos):

for(int i = 0; i< 10; i++) {
    try {
        //sending the actual Thread of execution to sleep X milliseconds
        Thread.sleep(3000);
    } catch(InterruptedException ie) {}
    System.out.println("Hello world!"):
}

Isso interromperá o encadeamento pelo menos X milissegundos. O encadeamento pode estar dormindo mais tempo, mas isso depende da JVM. A única coisa garantida é que o encadeamento durará pelo menos esses milissegundos. Dê uma olhada no Thread#sleepdocumento:

Faz com que o encadeamento atualmente em execução seja suspenso (interrompa temporariamente a execução) pelo número especificado de milissegundos, sujeito à precisão e exatidão dos cronômetros e planejadores do sistema .

Luiggi Mendoza
fonte
Obrigado @Luiggi. O Java sempre se certifica de que são 3000 ms, independentemente da máquina (CPU) que eu corro certo?
Meiryo 16/10/12
@NandkumarTekale gostaria de elaborar mais?
Meiryo 16/10/12
4
@meiryo Parará o thread pelo menos X milissegundos. O encadeamento pode estar dormindo mais tempo, mas isso depende da JVM. A única coisa garantida é que o encadeamento durará pelo menos esses milissegundos.
Luiggi Mendoza
4
Advertência: se este não for um sistema em tempo real, o sono será de pelo menos 3000 ms, mas poderá ser mais longo. Se você deseja exatamente 3000 ms de sono, especialmente onde a vida humana está em risco (instrumentos médicos, aviões de controle etc.), você deve usar um sistema operacional em tempo real.
Kinjal Dixit 16/10/12
1
@meiryo: Luiggi e Kinjal explicou muito bem :)
Nandkumar Tekale
3

O uso java.util.Timere o Timer#schedule(TimerTask,delay,period)método o ajudarão.

public class RemindTask extends TimerTask {
    public void run() {
      System.out.println(" Hello World!");
    }
    public static void main(String[] args){
       Timer timer = new Timer();
       timer.schedule(new RemindTask(), 3000,3000);
    }
  }
Subhrajyoti Majumder
fonte
2

Esta é a maneira simples de usar o thread em java:

for(int i = 0; i< 10; i++) {
    try {
        //sending the actual Thread of execution to sleep X milliseconds
        Thread.sleep(3000);
    } catch(Exception e) {
        System.out.println("Exception : "+e.getMessage());
    }
    System.out.println("Hello world!");
}
user3928455
fonte
1

O que ele disse. Você pode lidar com as exceções da maneira que desejar, mas Thread.sleep (milissegundos); é o melhor caminho a seguir.

public static void main(String[] args) throws InterruptedException {
leigero
fonte
1

Aqui está outra maneira simples de usar a interface Runnable no Thread Constructor

public class Demo {
    public static void main(String[] args) {
        Thread t1 = new Thread(new Runnable() {

            @Override
            public void run() {
                for(int i = 0; i < 5; i++){
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    System.out.println("Thread T1 : "+i);
                }
            }
        });

        Thread t2 = new Thread(new Runnable() {

            @Override
            public void run() {
                for(int i = 0; i < 5; i++) {
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    System.out.println("Thread T2 : "+i);
                }
            }
        });

        Thread t3 = new Thread(new Runnable() {

            @Override
            public void run() {
                for(int i = 0; i < 5; i++){
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    System.out.println("Thread T3 : "+i);
                }
            }
        });

        t1.start();
        t2.start();
        t3.start();
    }
}
Mayur Chudasama
fonte
0

Adicionar Thread.sleep

try {
        Thread.sleep(3000);
    } catch(InterruptedException ie) {}
Russell Gutierrez
fonte
-1

Para aplicativos pequenos, é bom usar o Timer e o TimerTask, como mencionou Rohit, mas em aplicativos da Web eu usaria o Quartz Scheduler para agendar trabalhos e realizar trabalhos periódicos.

Veja os tutoriais para agendamento de quartzo.

Nandkumar Tekale
fonte
-1
public class TimeDelay{
  public static void main(String args[]) {
    try {
      while (true) {
        System.out.println(new String("Hello world"));
        Thread.sleep(3 * 1000); // every 3 seconds
      }
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
  }
}
user3017805
fonte