Qu'est-ce que ExecutorService en Java et comment le créer?

Le langage de programmation Java fonctionne très efficacement avec les applications qui nécessitent que les tâches soient exécutées simultanément dans un thread. Il devient difficile pour une application d'exécuter simultanément un grand nombre de threads. Alors pour surmonter ce problème, est livré avec ExecutorService qui est une sous-interface du . Dans cet article, nous discuterons de la fonctionnalité d'ExecutorService en Java. Voici les sujets abordés dans ce blog:

• Qu'est-ce que Executor Framework?
• ExecutorService dans l'exemple Java
• Implémentations Java ExecutorService
  • ThreadPoolExecutor
  • ScheduledThreadPoolExecutor
• Utilisation d'ExecutorService
• Exécutable vs appelable
• Arrêt de l'ExecutorService

Qu'est-ce que Executor Framework?

Il est assez facile de créer et d'exécuter un ou deux threads simultanément. Mais cela devient difficile lorsque le nombre de threads augmente jusqu'à un nombre significatif. Les grandes applications multi-threads auront des centaines de threads exécutés simultanément. Par conséquent, il est parfaitement logique de séparer la création de thread de la gestion de thread dans une application.

L'exécuteur testamentaire est un vous aide à créer et à gérer des threads dans une application. La vous aide dans les tâches suivantes.

• Création de threads: il fournit une variété de méthodes pour la création de threads qui vous aident à exécuter vos applications simultanément.

  
  
  

• Thread Management: Il gère également le cycle de vie des threads. Vous n'avez pas à vous inquiéter si le thread est actif, occupé ou mort avant de soumettre la tâche pour exécution.

• Soumission et exécution de tâches: Le framework Executor fournit des méthodes pour la soumission de tâches dans le pool de threads.Il donne également le pouvoir de décider si le thread sera exécuté ou non.

ExecutorService dans l'exemple Java

Il s'agit d'une sous-interface du framework exécuteur qui ajoute certaines fonctionnalités pour gérer le cycle de vie des threads d'une application. Il fournit également une méthode submit () qui peut accepter à la fois exécutable et appelable objets.

Dans l'exemple suivant, nous allons créer un ExecutorService avec un seul thread, puis soumettre la tâche à exécuter à l'intérieur du thread.

import java.util.concurrent.ExecutorService import java.util.concurrent.Executors classe publique Exemple {public static void main (String [] args) {System.out.println ('Inside:' + Thread.currentThread (). getName ( )) System.out.println ('Creating ExecutorService') ExecutorService executorservice = Executors.newSingleThreadExecutor () System.out.println ('Creating a runnable') Runnable runnable = () -> {System.out.println ('inside: '+ Thread.currentThread (). GetName ())} System.out.println (' soumettre la tâche spécifiée par l'exécutable au service exécuteurs ') executorservice.submit (exécutable)}}

 Production: À l'intérieur: principal création d'ExecutorService création d'un exécutable soumettre la tâche spécifiée par l'exécutable au service exécuteurs à l'intérieur: pool-1-thread-1

Ce qui précède montre comment nous pouvons créer un ExecutorService et exécuter une tâche à l'intérieur de l'exécuteur. Si une tâche est soumise pour exécution et que le thread est actuellement occupé à exécuter une autre tâche, la tâche attendra dans une file d'attente jusqu'à ce que le thread soit libre de l'exécuter.

Lorsque vous exécutez le programme ci-dessus, le programme ne se fermera jamais. Vous devrez l'arrêter explicitement car le service exécuteur continue à écouter les nouvelles tâches.

Implémentations Java ExecutorService

ExecutorService est très similaire à un pool de threads. En fait, l'implémentation d'ExecutorService dans java.util.concurrent paquet est une implémentation de threadpool. ExecutorService a les implémentations suivantes dans le package java.util.concurrent:

ThreadPoolExecutor

ThreadPoolExecutor exécute les tâches données en utilisant l'un de ses threads regroupés en interne.

Créer un threadPoolExecutor

int corePoolSize = 5 int maxPoolSize = 10 long keepAliveTime = 5000 ExecutorService threadPoolExecutor = nouveau threadPoolExecutor (corePoolSize, maxPoolSize, keepAliveTime, TimeUnit.MILLISECONDS, new LinkedBlockingQueue ())

ScheduledThreadPoolExecutor

Le java.util.concurrent.ScheduledThreadPoolExecutor est un ExecutorService qui peut planifier des tâches à exécuter après un délai ou à s'exécuter à plusieurs reprises avec un intervalle de temps fixe entre chaque exécution.

Exemple

ScheduledExecutorService ScheduledExecutorservice = Executors.newScheduledThreadPool (5) ScheduledFuture ScheduledFuture = ScheduledExecutorService.schedule (new Callable () {public Object call () throws Exception {System.out.println ('exécuté') return 'called'}}, 5, TimeUnit. SECONDES)

Utilisation d'ExecutorService

Il existe plusieurs façons de déléguer des tâches à un ExecutorService.

• exécuter (exécutable)

• soumettre (exécutable)

• invokeAny ()

• invokeAll ()

Exécuter Runnable

Java ExecutorService execute (Runnable) prend un objet java.lang.Runnable et l'exécute de manière asynchrone.

ExecutorService executorService = Executors.newSingleThreadExecutor () executorService.execute (new Runnable () {public void run () {System.out.println ('asynchronous task')}}) executorService.shutdown ()

Il n'y a aucun moyen d'obtenir le résultat de l'exécution Runnable, pour cela vous devez utiliser Callable.

Soumettre Runnable

La méthode d'envoi Java ExecutorService (Runnable) prend une implémentation Runnable et renvoie un futur objet. Le futur objet peut être utilisé pour vérifier si le Runnable a fini de s'exécuter.

Future future = executorService.submit (new Runnable () {public void run () {System.out.println (: asynchronous task ')}}) future.get () // renvoie null si la tâche est terminée correctement.

Soumettre appelable

La méthode de soumission Java ExecutorService (Callable) est similaire à submit (Runnable) mais elle prend Java Callable au lieu de Runnable.

Future future = executorService.submit (new Callable () {public Object call () throws Exception {System.out.println ('Asynchronous callable') return 'Callable Result'}}) System.out.println ('future.get ( ) = 'future.get ())

 Production: Asynchroous callable future.get = Résultat appelable

invokeAny ()

La méthode invokeAny () prend une collection d'objets Callable. L'appel de cette méthode ne renvoie aucun futur, mais renvoie le résultat de l'un des objets Callable.

ExecutorService executorService = Executors.newSingleThreadExecutor () Ensemblecallables = nouveau HashSet() callables.add (new Callable () {public String call () throws Exception {return'task A '}}) callables.add (new Callable () {public String call () throws Exception {return'task B'} }) callables.add (new Callable () {public String call () throws Exception {return'task C '}}) String result = executorService.invokeAny (callables) System.out.println (' result = '+ result) executorService .fermer()

Lorsque vous exécutez le code ci-dessus, le résultat change. Cela peut être la tâche A, la tâche B, etc.

InvokeAll ()

La méthode invokeAll () appelle tous les objets Callable passés comme paramètres. Il renvoie les futurs objets qui peuvent être utilisés pour obtenir les résultats de l'exécution de chaque Callable.

ExecutorService executorService = Executors.newSingleThreadExecutor () Ensemblecallables = nouveau HashSet() callables.add (new Callable () {public String call () throws Exception {return 'Task A'}}) callables.add (new Callable () {public String call () throws Exception {return 'Task B'} }) callables.add (new Callable () {public String call () throws Exception {return 'Task C'}}) Listefutures = executorService.invokeAll (callables) for (Future future: futures) {System.out.println ('future.get =' + future.get ())} executorService.shutdown ()

Exécutable vs appelable

Les interfaces exécutables et appelables sont très similaires les unes aux autres. La différence est visible dans la déclaration du les interfaces. Les deux interfaces représentent une tâche qui peut être exécutée simultanément par un thread ou ExecutorService.

Déclaration appelable:

interface publique Callable {l'appel d'objet public () lève une exception}

Déclaration exécutable:

interface publique Runnable {public void run ()}

La principale différence entre les deux est que la méthode call () peut renvoyer un objet à partir de l'appel de méthode. Et la méthode call () peut lancer un tandis que la méthode run () ne peut pas.

is-a and has-a relation en java

annuler la tâche

Vous pouvez annuler la tâche soumise à ExecutorService en appelant simplement la méthode cancel sur le futur soumis lorsque la tâche est soumise.

future.cancel ()

Arrêt de l'ExecutorService

Afin d'empêcher les threads de s'exécuter même une fois l'exécution terminée, vous devez arrêter ExecutorService.

fermer()

Pour terminer les threads dans un ExecutorService, vous pouvez appeler la méthode shutdown ().

executorService.shutdown ()

Cela nous amène à la fin de cet article où nous avons appris comment utiliser ExecutorService pour exécuter des tâches dans un thread. J'espère que vous êtes clair avec tout ce qui a été partagé avec vous dans ce tutoriel.

Si vous avez trouvé cet article sur «ExecutorService en Java» pertinent, consultez le une entreprise de formation en ligne de confiance avec un réseau de plus de 250 000 apprenants satisfaits répartis dans le monde entier.

Nous sommes là pour vous aider à chaque étape de votre voyage et proposer un programme conçu pour les étudiants et les professionnels qui souhaitent devenir développeur Java. Le cours est conçu pour vous donner une longueur d'avance dans la programmation Java et vous former aux concepts Java de base et avancés ainsi que divers comme Hiberner & .

Si vous rencontrez des questions, n'hésitez pas à poser toutes vos questions dans la section commentaires de «ExecutorService en Java» et notre équipe se fera un plaisir de vous répondre.