Interface ExecutorService

Une interface java.util.concurrent.ExecutorService est une sous-interface de l'interface Executor et ajoute des fonctionnalités pour gérer le cycle de vie, à la fois des tâches individuelles et de l'exécuteur lui-même.

Méthodes ExecutorService

N ° Sr.	Méthode et description
1	boolean awaitTermination(long timeout, TimeUnit unit) Bloque jusqu'à ce que toutes les tâches aient terminé l'exécution après une demande d'arrêt, ou que le délai d'expiration se produise ou que le thread en cours soit interrompu, selon la première éventualité.
2	<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) Exécute les tâches données, renvoyant une liste de Futures conservant leur statut et leurs résultats lorsque tout est terminé.
3	<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) Exécute les tâches données, renvoyant une liste de Futures conservant leur statut et leurs résultats lorsque tout est terminé ou que le délai expire, selon la première éventualité.
4	<T> T invokeAny(Collection<? extends Callable<T>> tasks) Exécute les tâches données, en retournant le résultat d'une tâche qui s'est terminée avec succès (c'est-à-dire sans lever d'exception), le cas échéant.
5	<T> T invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) Exécute les tâches données, en retournant le résultat d'une tâche qui s'est terminée avec succès (c'est-à-dire sans lever d'exception), le cas échéant avant la fin du délai imparti.
6	boolean isShutdown() Renvoie true si cet exécuteur a été arrêté.
sept	boolean isTerminated() Renvoie true si toutes les tâches sont terminées après l'arrêt.
8	void shutdown() Lance un arrêt ordonné dans lequel les tâches précédemment soumises sont exécutées, mais aucune nouvelle tâche ne sera acceptée.
9	List<Runnable> shutdownNow() Tente d'arrêter toutes les tâches en cours d'exécution, interrompt le traitement des tâches en attente et renvoie une liste des tâches en attente d'exécution.
dix	<T> Future<T> submit(Callable<T> task) Soumet une tâche de retour de valeur pour exécution et renvoie un Future représentant les résultats en attente de la tâche.
11	Future<?> submit(Runnable task) Soumet une tâche exécutable pour exécution et renvoie un Future représentant cette tâche.
12	<T> Future<T> submit(Runnable task, T result) Soumet une tâche exécutable pour exécution et renvoie un Future représentant cette tâche.

Exemple

Le programme TestThread suivant montre l'utilisation de l'interface ExecutorService dans un environnement basé sur les threads.

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class TestThread {

   public static void main(final String[] arguments) throws InterruptedException {
      ExecutorService executor = Executors.newSingleThreadExecutor();

      try {
         executor.submit(new Task());
         System.out.println("Shutdown executor");
         executor.shutdown();
         executor.awaitTermination(5, TimeUnit.SECONDS);
      } catch (InterruptedException e) {
         System.err.println("tasks interrupted");
      } finally {

         if (!executor.isTerminated()) {
            System.err.println("cancel non-finished tasks");
         }
         executor.shutdownNow();
         System.out.println("shutdown finished");
      }
   }

   static class Task implements Runnable {
      
      public void run() {
         
         try {
            Long duration = (long) (Math.random() * 20);
            System.out.println("Running Task!");
            TimeUnit.SECONDS.sleep(duration);
         } catch (InterruptedException e) {
            e.printStackTrace();
         }
      }
   }	   
}

Cela produira le résultat suivant.

Production

Shutdown executor
Running Task!
shutdown finished
cancel non-finished tasks
java.lang.InterruptedException: sleep interrupted
	at java.lang.Thread.sleep(Native Method)
	at java.lang.Thread.sleep(Thread.java:302)
	at java.util.concurrent.TimeUnit.sleep(TimeUnit.java:328)
	at TestThread$Task.run(TestThread.java:39)
	at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:439)
	at java.util.concurrent.FutureTask$Sync.innerRun(FutureTask.java:303)
	at java.util.concurrent.FutureTask.run(FutureTask.java:138)
	at java.util.concurrent.ThreadPoolExecutor$Worker.runTask(ThreadPoolExecutor.java:895)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:918)
	at java.lang.Thread.run(Thread.java:662)