web-dev-qa-db-fra.com

Imprimez "Bonjour tout le monde" toutes les X secondes

Dernièrement, j'utilise 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 utilisé aucune bibliothèque de minuterie dans Java. Comment modifier ce qui précède pour imprimer toutes les 3 secondes?

javatimer
117
meiryo

Vous pouvez également consulter les classes Timer et TimerTask que vous pouvez utiliser pour planifier l'exécution de votre tâche toutes les n secondes.

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

Voici un exemple qui affiche Hello World toutes 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);
172
Rohit Jain

Si vous souhaitez effectuer une tâche périodique, utilisez un ScheduledExecutorService. Plus précisément 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);
182
Tim Bender

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 sera exécuté print to console Hello World tous les 5000 millisecondes ( 5 secondes). Pour plus d'informations, lisez https://docs.Oracle.com/javase/1.5.0/docs/api/Java/util/Timer.html

32
user4475555

Je le découvre avec une minuterie, j'espère que ça aide. J'ai utilisé un timer de Java.util.Timer et TimerTask du 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);
13
tmwanik

Utilisez Thread.sleep (3000) à l’intérieur de la boucle

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

la boucle infinie est créée et la tâche du planificateur est configurée.

4
Vicky

Le moyen le plus simple consiste à définir le thread principal pour qu'il dorme en 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 de temps, mais cela dépend de la JVM. La seule chose garantie est que le thread dormira au moins ces millisecondes. Jetez un coup d'œil au Thread#sleep doc:

Fait suspendre temporairement l'exécution du thread en cours d'exécution pendant le nombre spécifié de millisecondes , sous réserve de la précision et de l'exactitude des temporisateurs et programmateurs du système .

3
Luiggi Mendoza

Utilisez Java.util.Timer et Timer#schedule(TimerTask,delay,period), la méthode vous aidera.

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);
    }
  }
3
Subhrajyoti Majumder

C'est le moyen simple d'utiliser 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!");
}
2
user3928455

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

Ce qu'il a dit. Vous pouvez gérer les exceptions comme bon vous semble, mais Thread.sleep (millisecondes); est le meilleur itinéraire à prendre.

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