Imprime "hola mundo" cada X segundos

Últimamente he estado usando bucles con 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++;
}

Entiendo que esta es una forma muy tonta de hacerlo, pero nunca he usado ninguna biblioteca de temporizadores en Java todavía. ¿Cómo se modificaría lo anterior para imprimir cada 3 segundos, por ejemplo?

También puede echar un vistazo a Timery TimerTaskclases que se pueden utilizar para programar su tarea para ejecutar cada nsegundo.

Necesita una clase que amplíe TimerTasky anule el public void run()método, que se ejecutará cada vez que pase una instancia de esa clase al timer.schedule()método.

Aquí hay un ejemplo, que imprime 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);

Si desea hacer una tarea periódica, use a ScheduledExecutorService. Específicamente ScheduledExecutorService.scheduleAtFixedRate

El 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);

Intenta hacer esto:

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

Este código ejecutará print para consolar Hello World cada 5000 milisegundos ( 5 segundos). Para obtener más información, lea https://docs.oracle.com/javase/1.5.0/docs/api/java/util/Timer.html

Lo resuelvo con un temporizador, espero que ayude. He usado un temporizador desde java.util.Timery TimerTaskdesde el mismo paquete. Vea abajo:

TimerTask task = new TimerTask() {

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

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

Puedes usar Thread.sleep(3000)dentro para loop.

Nota: Esto requerirá un try/catchbloqueo.

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

se crea un bucle infinito y se configura la tarea del planificador de anuncios.

La forma más fácil sería configurar el hilo principal para que duerma 3000 milisegundos (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!"):
}

Esto detendrá el hilo al menos X milisegundos. El hilo podría estar durmiendo más tiempo, pero eso depende de la JVM. Lo único garantizado es que el hilo dormirá al menos esos milisegundos. Echa un vistazo al Thread#sleepdocumento:

Hace que el subproceso que se está ejecutando actualmente se suspenda (cesa temporalmente la ejecución) durante el número especificado de milisegundos, sujeto a la precisión y exactitud de los temporizadores y programadores del sistema .

El uso java.util.Timery el Timer#schedule(TimerTask,delay,period)método te ayudarán.

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

Esta es la forma simple de usar hilo en 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!");
}

Lo que dijo. Puede manejar las excepciones como quiera, pero Thread.sleep (milisegundos); Es la mejor ruta a seguir.

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

Aquí hay otra forma simple de usar la interfaz Runnable en 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();
    }
}

Añadir Thread.sleep

try {
        Thread.sleep(3000);
    } catch(InterruptedException ie) {}

Para aplicaciones pequeñas está bien usar Timer y TimerTask como mencionó Rohit, pero en aplicaciones web usaría Quartz Scheduler para programar trabajos y realizar dichos trabajos periódicos.

Ver tutoriales para la programación de cuarzo.

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