Stampa "ciao mondo" ogni X secondi

Ultimamente ho usato loop con grandi numeri per stampare 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++;
}

Capisco che questo è un modo molto sciocco per farlo, ma non ho mai usato nessuna libreria di timer in Java. Come si modifica quanto sopra per stampare ogni 3 secondi?

Puoi anche dare un'occhiata Timere TimerTaskclassi che puoi utilizzare per pianificare l'esecuzione ndell'attività ogni secondo.

È necessaria una classe che estende TimerTaske sovrascrive il public void run()metodo, che verrà eseguito ogni volta che si passa un'istanza di quella classe al timer.schedule()metodo.

Ecco un esempio, che stampa Hello Worldogni 5 secondi: -

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

Se si desidera eseguire un'attività periodica, utilizzare a ScheduledExecutorService. Specificamente ScheduledExecutorService.scheduleAtFixedRate

Il codice:

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

ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
executor.scheduleAtFixedRate(helloRunnable, 0, 3, TimeUnit.SECONDS);

Prova a fare questo:

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

Questo codice verrà eseguito per stampare su Hello World ogni 5000 millisecondi ( 5 secondi). Per maggiori informazioni, leggi https://docs.oracle.com/javase/1.5.0/docs/api/java/util/Timer.html

Lo capisco con un timer, spero che aiuti. Ho usato un timer da java.util.Timere TimerTaskper lo stesso pacchetto. Vedi sotto:

TimerTask task = new TimerTask() {

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

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

Puoi usare Thread.sleep(3000)inside per loop.

Nota: questo richiederà un try/catchblocco.

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

viene creato un ciclo infinito L'attività di pianificazione annunci è configurata.

Il modo più semplice sarebbe impostare il thread principale su 3000 millisecondi (3 secondi):

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!"):
}

Ciò interromperà il thread di almeno X millisecondi. Il thread potrebbe dormire più tempo, ma dipende dalla JVM. L'unica cosa garantita è che il thread dormirà almeno quei millisecondi. Dai un'occhiata aThread#sleep documento:

Fa in modo che il thread attualmente in esecuzione venga sospeso (interrompa temporaneamente l'esecuzione) per il numero specificato di millisecondi, soggetto alla precisione e all'accuratezza dei timer e degli scheduler del sistema .

L'uso java.util.Timere il Timer#schedule(TimerTask,delay,period)metodo ti aiuteranno.

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

Questo è il modo semplice di usare il thread in 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!");
}

Cosa ha detto. Puoi gestire le eccezioni come preferisci, ma Thread.sleep (millisecondi); è il percorso migliore da prendere.

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

Ecco un altro modo semplice utilizzando l'interfaccia Runnable in 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();
    }
}

Inserisci Thread.sleep

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

Per piccole applicazioni è bene usare Timer e TimerTask come indicato da Rohit, ma nelle applicazioni Web utilizzerei Quartz Scheduler per pianificare lavori ed eseguire tali lavori periodici.

Vedi tutorial per la programmazione al quarzo.

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