Imprimez «bonjour le monde» toutes les X secondes

Dernièrement, j'ai utilisé des boucles avec de grands nombres pour imprimer 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++;
}

Je comprends que c'est une façon très idiote de le faire, mais je n'ai encore jamais utilisé de bibliothèques de minuterie en Java. Comment modifierait-on ce qui précède pour imprimer toutes les 3 secondes?

Vous pouvez également jeter un oeil à Timeret les TimerTaskclasses que vous pouvez utiliser pour planifier votre tâche à exécuter toutes les nsecondes.

Vous avez besoin d'une classe qui étend TimerTasket remplace la public void run()méthode, qui sera exécutée chaque fois que vous transmettez une instance de cette classe à timer.schedule()method.

Voici un exemple, qui s'imprime Hello Worldtoutes les 5 secondes: -

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 vous souhaitez effectuer une tâche périodique, utilisez un fichier ScheduledExecutorService. Spécifiquement ScheduledExecutorService.scheduleAtFixedRate

Le code:

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

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

Essayez de faire ceci:

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

Ce code exécutera l'impression sur la console Hello World toutes les 5000 millisecondes ( 5 secondes). Pour plus d'informations, lisez https://docs.oracle.com/javase/1.5.0/docs/api/java/util/Timer.html

Je le comprends avec une minuterie, j'espère que cela aide. J'ai utilisé une minuterie du java.util.Timeret TimerTaskdu même paquet. Voir ci-dessous:

TimerTask task = new TimerTask() {

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

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

Vous pouvez utiliser Thread.sleep(3000)inside for loop.

Remarque: cela nécessitera un try/catchblocage.

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

une boucle infinie est créée. La tâche du planificateur d'annonces est configurée.

Le moyen le plus simple serait de mettre le thread principal en veille de 3000 millisecondes (3 secondes):

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

Cela arrêtera le thread au moins X millisecondes. Le thread pourrait dormir plus longtemps, mais cela dépend de la JVM. La seule chose garantie est que le thread dormira au moins ces millisecondes. Jetez un œil à la Thread#sleepdoc:

Provoque la mise en veille du thread en cours d'exécution (arrêt temporaire de l'exécution) pendant le nombre de millisecondes spécifié, sous réserve de la précision et de l'exactitude des minuteries et des planificateurs système .

L'utilisation java.util.Timeret la Timer#schedule(TimerTask,delay,period)méthode vous aideront.

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

Voici le moyen simple d'utiliser le thread 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!");
}

Ce qu'il a dit. Vous pouvez gérer les exceptions comme vous le souhaitez, mais Thread.sleep (millisecondes); est la meilleure route à emprunter.

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

Voici un autre moyen simple d'utiliser l'interface Runnable dans 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();
    }
}

Ajouter Thread.sleep

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

Pour les petites applications, il est bien d'utiliser Timer et TimerTask comme Rohit l'a mentionné, mais dans les applications Web, j'utiliserais Quartz Scheduler pour planifier des tâches et effectuer de telles tâches périodiques.

Voir les tutoriels pour la planification Quartz.

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