Le Java ExecutorService est l'interface qui nous permet d'exécuter des tâches sur des threads de manière asynchrone. L'interface Java ExecutorService est présente dans le package java.util.concurrent. L'ExecutorService aide à maintenir un pool de threads et leur attribue des tâches. Il offre également la possibilité de mettre les tâches en file d'attente jusqu'à ce qu'un thread libre soit disponible si le nombre de tâches est supérieur au nombre de threads disponibles.

Méthodes de Java ExecutorService

Un programme simple de Java ExecutorService

 public class ExecutorServiceExample { public static void main(String[] args) { ExecutorService executorService = Executors.newFixedThreadPool(10); executorService.execute(new Runnable() { @Override public void run() { System.out.println('ExecutorService'); } }); executorService.shutdown(); } } 

Sortir:

Dans ce programme, nous créons un ExecutorService avec dix threads et lui attribuons une implémentation exécutable anonyme qui exécute une tâche pour imprimer « ExecutorService » et une fois sa tâche terminée, nous arrêtons le service exécuteur.

Comment utiliser Java ExecutorService

Instanciation d'ExecutorService

Nous pouvons utiliser Java ExecutorService pour créer un seul thread, un pool de threads ou un pool de threads planifié. La classe Executors fournit des méthodes d'usine pour instancier un ExecutorService comme suit :

 ExecutorService executorService1 = Executors.newSingleThreadExecutor(); //Creates //a ExecutorService object having a single thread. ExecutorService executorService2 = Executors.newFixedThreadPool(10); // Creates a //ExecutorService object having a pool of 10 threads. ExecutorService executorService3 = Executors.newScheduledThreadPool(10); //Creates a scheduled thread pool executor with 10 threads. In scheduled thread //pool, we can schedule tasks of the threads. 

Affectation de tâches à ExecutorServices

Pour attribuer une tâche à ExecutorService, nous pouvons utiliser les méthodes suivantes :

• exécuter (tâche exécutable)
• soumettre (tâche exécutable) / soumettre (tâche appelable)
• invoqueAny(CollectionTâches)
• invoqueTout(CollectionTâches)

Exemple d'attribution d'une tâche à ExecutorService à l'aide de la méthode execute()

La méthode execute() de Java ExecutorService récupère un objet exécutable et exécute sa tâche de manière asynchrone. Après avoir appelé la méthode d'exécution, nous appelons la méthode d'arrêt, qui bloque toute autre tâche à mettre en file d'attente dans executorService.

 public class ExecutorServiceExample { public static void main(String[] args) { ExecutorService executorService = Executors.newSingleThreadExecutor(); executorService.execute(new Runnable() { @Override public void run() { System.out.println('ExecutorService'); } }); executorService.shutdown(); } } 

Sortir:

 ExecutorService 

Exemple d'attribution d'une tâche à ExecutorService à l'aide de submit()

La méthode submit() récupère un objet exécutable et renvoie un objet Future. Cet objet est ensuite utilisé pour vérifier l'état de Runnable s'il a terminé son exécution ou non.

 public class ExecutorServiceExample { public static void main(String[] args) { ExecutorService executorService = Executors.newSingleThreadExecutor(); executorService.submit(new Runnable() { @Override public void run() { System.out.println('ExecutorService'); } }); } } 

Exemple d'attribution d'une tâche à ExecutorService à l'aide de la méthode EnsureAny()

La méthode InvoqueAny() prend une collection d'objets Callablle ou d'objets de classes implémentant Callable. Cette méthode renvoie le futur objet de l'objet appelable qui est exécuté avec succès en premier.

langage prologue

 public class ExecutorServiceExample { public static void main(String[] args) throws InterruptedException, ExecutionException { ExecutorService executorService = Executors.newSingleThreadExecutor(); Set<callable> callables = new HashSet<callable>(); callables.add(new Callable() { public String call() throws Exception { return &apos;Task 1&apos;; } }); callables.add(new Callable() { public String call() throws Exception { return &apos;Task 2&apos;; } }); callables.add(new Callable() { public String call() throws Exception { return &apos;Task 3&apos;; } }); String result = executorService.invokeAny(callables); System.out.println(&apos;result = &apos; + result); executorService.shutdown(); } } </callable></callable>

Sortir:

 result = Task 1 

Le résultat stocke la tâche 1 car le premier objet appelable est exécuté avec succès en premier.

Exemple d'attribution d'une tâche à ExecutorService à l'aide de la méthode EnsureAll()

La méthode InvoqueAll() prend en compte une collection d'objets appelables ayant des tâches et renvoie une liste d'objets Future contenant le résultat de toutes les tâches.

 public class ExecutorServiceExample { public static void main(String[] args) throws InterruptedException, ExecutionException { ExecutorService executorService = Executors.newSingleThreadExecutor(); Set<callable> callables = new HashSet<callable>(); callables.add(new Callable() { public String call() throws Exception { return &apos;Task 1&apos;; } }); callables.add(new Callable() { public String call() throws Exception { return &apos;Task 2&apos;; } }); callables.add(new Callable() { public String call() throws Exception { return &apos;Task 3&apos;; } }); java.util.List<future> futures = executorService.invokeAll(callables); for(Future future : futures){ System.out.println(&apos;future.get = &apos; + future.get()); } executorService.shutdown(); } } </future></callable></callable>

Sortir:

 future.get = Task 1 future.get = Task 3 future.get = Task 2 

Comment arrêter ExecutorService

Une fois que nous avons terminé nos tâches confiées à ExecutorService, nous devons l'arrêter car ExecutorService exécute la tâche sur différents threads. Si nous n'arrêtons pas ExecutorService, les threads continueront à fonctionner et la JVM ne s'arrêtera pas.

Le processus d'arrêt peut être effectué par les trois méthodes suivantes :

• Méthode d'arrêt()
• Méthode shutdownNow()
• Méthode waitTermination()