Java : définir un délai d'attente sur un certain bloc de code ?

Question

Est-il possible de forcer Java à lancer une exception lorsqu'un bloc de code s'exécute plus longtemps que prévu ?

Answer 1

Voici le moyen le plus simple que je connaisse pour le faire :

final Runnable stuffToDo = new Thread() {
  @Override 
  public void run() { 
    /* Do stuff here. */ 
  }
};

final ExecutorService executor = Executors.newSingleThreadExecutor();
final Future future = executor.submit(stuffToDo);
executor.shutdown(); // This does not cancel the already-scheduled task.

try { 
  future.get(5, TimeUnit.MINUTES); 
}
catch (InterruptedException ie) { 
  /* Handle the interruption. Or ignore it. */ 
}
catch (ExecutionException ee) { 
  /* Handle the error. Or ignore it. */ 
}
catch (TimeoutException te) { 
  /* Handle the timeout. Or ignore it. */ 
}
if (!executor.isTerminated())
    executor.shutdownNow(); // If you want to stop the code that hasn't finished.

Vous pouvez également créer une classe TimeLimitedCodeBlock pour envelopper cette fonctionnalité, puis l'utiliser partout où vous en avez besoin comme suit :

new TimeLimitedCodeBlock(5, TimeUnit.MINUTES) { @Override public void codeBlock() {
    // Do stuff here.
}}.run();

Answer 2

J'ai compilé certaines des autres réponses en une seule méthode utilitaire :

public class TimeLimitedCodeBlock {

  public static void runWithTimeout(final Runnable runnable, long timeout, TimeUnit timeUnit) throws Exception {
    runWithTimeout(new Callable<Object>() {
      @Override
      public Object call() throws Exception {
        runnable.run();
        return null;
      }
    }, timeout, timeUnit);
  }

  public static <T> T runWithTimeout(Callable<T> callable, long timeout, TimeUnit timeUnit) throws Exception {
    final ExecutorService executor = Executors.newSingleThreadExecutor();
    final Future<T> future = executor.submit(callable);
    executor.shutdown(); // This does not cancel the already-scheduled task.
    try {
      return future.get(timeout, timeUnit);
    }
    catch (TimeoutException e) {
      //remove this if you do not want to cancel the job in progress
      //or set the argument to 'false' if you do not want to interrupt the thread
      future.cancel(true);
      throw e;
    }
    catch (ExecutionException e) {
      //unwrap the root cause
      Throwable t = e.getCause();
      if (t instanceof Error) {
        throw (Error) t;
      } else if (t instanceof Exception) {
        throw (Exception) t;
      } else {
        throw new IllegalStateException(t);
      }
    }
  }

}

Exemple de code faisant appel à cette méthode utilitaire :

  public static void main(String[] args) throws Exception {
    final long startTime = System.currentTimeMillis();
    log(startTime, "calling runWithTimeout!");
    try {
      TimeLimitedCodeBlock.runWithTimeout(new Runnable() {
        @Override
        public void run() {
          try {
            log(startTime, "starting sleep!");
            Thread.sleep(10000);
            log(startTime, "woke up!");
          }
          catch (InterruptedException e) {
            log(startTime, "was interrupted!");
          }
        }
      }, 5, TimeUnit.SECONDS);
    }
    catch (TimeoutException e) {
      log(startTime, "got timeout!");
    }
    log(startTime, "end of main method!");
  }

  private static void log(long startTime, String msg) {
    long elapsedSeconds = (System.currentTimeMillis() - startTime);
    System.out.format("%1$5sms [%2$16s] %3$s\n", elapsedSeconds, Thread.currentThread().getName(), msg);
  }

Résultat de l'exécution de l'exemple de code sur ma machine :

    0ms [            main] calling runWithTimeout!
   13ms [ pool-1-thread-1] starting sleep!
 5015ms [            main] got timeout!
 5016ms [            main] end of main method!
 5015ms [ pool-1-thread-1] was interrupted!

Answer 3

Oui, mais c'est généralement une très mauvaise idée de forcer un autre thread à s'interrompre sur une ligne de code aléatoire. Vous ne devriez le faire que si vous avez l'intention d'arrêter le processus.

Ce que vous pouvez faire est d'utiliser Thread.interrupt() pour une tâche après un certain temps. Cependant, à moins que le code ne vérifie ce point, cela ne fonctionnera pas. Un ExecutorService peut rendre cela plus facile avec Future.cancel(true)

C'est bien mieux pour le code de se chronométrer et de s'arrêter quand il le faut.

Answer 4

Si c'est du code de test que vous voulez chronométrer, alors vous pouvez utiliser la fonction time attribut :

@Test(timeout = 1000)  
public void shouldTakeASecondOrLess()
{
}

S'il s'agit d'un code de production, il n'y a pas de mécanisme simple, et la solution que vous utilisez dépend de la possibilité de modifier le code pour qu'il soit temporisé ou non.

Si vous pouvez modifier le code chronométré, une approche simple consiste à faire en sorte que votre code chronométré se souvienne de son heure de départ et à comparer périodiquement l'heure actuelle avec celle-ci. Par exemple

long startTime = System.currentTimeMillis();
// .. do stuff ..
long elapsed = System.currentTimeMillis()-startTime;
if (elapsed>timeout)
   throw new RuntimeException("tiomeout");

Si le code lui-même ne peut pas vérifier le délai d'attente, vous pouvez exécuter le code sur un autre thread, et attendre l'achèvement, ou le délai d'attente.

    Callable<ResultType> run = new Callable<ResultType>()
    {
        @Override
        public ResultType call() throws Exception
        {
            // your code to be timed
        }
    };

    RunnableFuture future = new FutureTask(run);
    ExecutorService service = Executors.newSingleThreadExecutor();
    service.execute(future);
    ResultType result = null;
    try
    {
        result = future.get(1, TimeUnit.SECONDS);    // wait 1 second
    }
    catch (TimeoutException ex)
    {
        // timed out. Try to stop the code if possible.
        future.cancel(true);
    }
    service.shutdown();
}

Answer 5

Je peux vous proposer deux options.

1. Dans la méthode, en supposant qu'elle tourne en boucle et qu'elle n'attend pas un événement externe, ajoutez un champ local et testez le temps à chaque tour de boucle.

   void method() {
       long endTimeMillis = System.currentTimeMillis() + 10000;
       while (true) {
           // method logic
           if (System.currentTimeMillis() > endTimeMillis) {
               // do some clean-up
               return;
           }
       }
   }

2. Exécutez la méthode dans un thread, et demandez à l'appelant de compter jusqu'à 10 secondes.

   Thread thread = new Thread(new Runnable() {
           @Override
           public void run() {
               method();
           }
   });
   thread.start();
   long endTimeMillis = System.currentTimeMillis() + 10000;
   while (thread.isAlive()) {
       if (System.currentTimeMillis() > endTimeMillis) {
           // set an error flag
           break;
       }
       try {
           Thread.sleep(500);
       }
       catch (InterruptedException t) {}
   }

L'inconvénient de cette approche est que la méthode() ne peut pas retourner une valeur directement, elle doit mettre à jour un champ d'instance pour retourner sa valeur.