Exécuter du code pendant x secondes en Java?

Comme déjà mentionné par d'autres affiches, si vous voulez juste que le fil s'arrête pendant un certain temps, Utilisez Thread.sleep().

Si vous voulez que le thread fasse quelque chose, mais que vous voulez le faire arrêter après un certain temps, utilisez quelque chose comme:

class Foo implements Runnable {
    private volatile boolean killed = false;

    public void run() {
        while (!killed) {
            try { doOnce(); } catch (InterruptedException ex) { killed = true; }
        }
    }

    public void kill() { killed = true; }
    private void doOnce() throws InterruptedException { /* .. */ }
}

Et à partir du thread principal, faites:

Foo foo = new Foo(); 
Thread thread = new Thread(foo);
thread.start();

/* when you want to stop it */
foo.kill();
thread.interrupt();

Essayez ceci:

public class SleepMessages {
    public static void main(String args[]) throws InterruptedException {
        String importantInfo[] = {
            "Mares eat oats",
            "Does eat oats",
            "Little lambs eat ivy",
            "A kid will eat ivy too"
        };

        for (int i = 0; i < importantInfo.length; i++) {
            //Pause for 15 seconds
            Thread.sleep(15000);
            //Print a message
            System.out.println(importantInfo[i]);
        }
    }
}

Plus d'infos : ici

Votre approche générale semble bien bien que vous souhaitiez voir si l'heure actuelle est supérieure au point que vous voulez arrêter, sinon vous risquez de courir longtemps.

L'alternative est d'exécuter une minuterie / thread qui définit un indicateur après 15 secondes se sont écoulées. Cet indicateur devrait être marqué comme volatile sinon votre boucle pourrait ne pas voir le changement se produire dans la valeur.

Le choix si vous vous souciez de l'efficacité est ce qui est plus cher, obtenir le temps du système une fois par boucle ou accéder à une variable volatile? Je ne sais pas lequel est le plus efficace - vous pouvez le comparer si c'est vraiment important.

Pour un code simple et maintenable, je choisirais l'approche de vérification de la minuterie:

long endTime = System.currentTimeMillis() + 15000
while (System.currentTimeMillis() < endTime) {
  //loop
} 

Vous pouvez utiliser AOP et a @Timeable annotation de jcabi-aspects (je suis un développeur):

@Timeable(limit = 1, unit = TimeUnit.SECONDS)
String load(String resource) {
  // do this check regularly:
  if (Thread.currentThread.isInterrupted()) {
    throw new IllegalStateException("time out");
  }
  // execution as normal
}

Lorsque la limite de temps est atteinte, votre thread obtiendra interrupted() flag défini sur true et c'est votre travail de gérer cette situation correctement et d'arrêter l'exécution.

En supposant que vous voulez que la boucle fasse quelque chose de sensé, vous pourriez trouver plus rapide de vérifier un drapeau volatile. Demandez à un autre thread d'attendre 15 secondes (ou utilisez une minuterie), puis réglez-le.

Alternativement, si vous savez à peu près combien de temps le corps de la boucle prendra, exécutez - le quelques centaines de fois, disons, et faites le contrôle du temps dans une boucle externe.

final long start = System.nanoTime();
do {
    for (int i=0; i<200, ++i) {
        ...
    }
} while (System.nanoTime()-start < 15L*1000L*1000L*1000L);

System.nanoTime ne devrait pas être confondu par les changements d'horloge système. L'utilisation de nombres littéraux longs est importante.

Vous pourriez être intéressé par la planification D'une TimerTask qui arrête un autre thread ou modifie l'état de votre boucle.

Ne vérifiez jamais l'heure actuelle dans une boucle serrée.

Sinon, quelqu'un avec un ordinateur portable peut se faire brûler ses genoux par un processeur surchauffé. J'ai entendu les histoires de ce qui se passe réellement.

Pour le java.util.approche concurrente , Voir Chapitre 6 de la concurrence Java dans la pratique (section 6.3.7 fixer des limites de temps sur les tâches, page 131).

Exemple de Code: extraction d'une publicité avec un budget de temps.

Une solution similaire à @Tom Hawtin Sans Taille de boucle arbitraire.

final long end = System.nanoTime() + 15 * 1000 * 1000 * 1000L;
int loop = 1;
do {
    for (int i=0; i<loop; ++i) {
        ...
    }
    loop++;
} while (System.nanoTime() < end);

Dans ce cas, la taille de la boucle interne commencera petite mais augmentera si la boucle est particulièrement rapide. S'il est assez lent, il ne peut itérer qu'une seule fois.

Voici ma suggestion et ça marche bien pour moi:)

StoppingTime = 15 ;
int loop = 1;
long StartTime = System.currentTimeMillis() / 1000 ;
for (int i=0; i<loop; ++i) {
    // your code here

    loop++;
    if (((System.currentTimeMillis()/1000) - StartTime) > StoppingTime)
        loop=0;
}

Je vous suggère de le faire avec la classe timer en évitant le Fil.sommeil (xxx); méthode.

Par exemple:

import java.util.Timer;
import java.util.TimerTask;

public class TimerExample {
    private int globalTimer = 0;
    private int limitTimer = 15;

    public static void main(String[] args) {
        new TimerExample();
    }

    public TimerExample() {
        Timer timer = new Timer();
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                globalTimer++;
                // DO YOUR CODE HERE
                System.out.println("running");
                if (globalTimer == limitTimer) {
                    timer.cancel();
                }
            }
        }, 0, 1000);
    }
}