🥇 🥇 Concurrence en Java: Cadre d'exécution

Introduction

Avec l’augmentation du nombre de cœurs disponibles dans les processeurs aujourd’hui, le long de la journée. Avec la nécessité croissante d’atteindre une plus grande performance, les API multi-threads deviennent assez populaires. Java proporciona su propio marco de subprocesos múltiples llamado Marco del ejecutor.

¿Qué es Executor Framework?

Executor Framework contiene una serie de componentes que se utilizan para administrar de manera eficiente los subprocesos de travail. L’API de l’exécuteur découle l’exécution de la tâche de tâche réelle qui sera exécutée par Executors. Cette conception est l’une des implémentations du modèle de producteur-consommateur.

Le java.util.concurrent.Executors Fournissez des méthodes d’usine utilisés pour créer ThreadPools de threads de travail.

Utiliser le cadre exécutant, nous devons créer l’un de ces groupes de sous-processus et envoyer la tâche à exécuter. Est le travail du programme-cadre exécuteur et exécuter les tâches envoyées et renvoyer les résultats du groupe de sous-traités.

Une question de base qui me vient à l’esprit est la raison de ce que nous avons besoin de tels groupes de sous-processus lorsque nous pouvons créer des objets de java.lang.Thread ou implémenter Runnable /

interfaces pour atteindre le parallélisme?

La réponse est réduite à deux faits de base:

La création d’un nouveau thread pour une nouvelle tâche implique une surcharge de création et de démontage du fil. La gestion du cycle de vie de ce fil augmente considérablement l’heure d’exécution.
ajoutez un nouveau fil pour chaque processus sans aucun type de limitation conduit à la création d’un grand nombre de fils. Ces sous-processus occupent la mémoire et provoquent des ressources de déchets. La CPU commence à consacrer trop de temps à changer de contexte lorsque chaque thread est échangé et qu’un autre thread est entré pour l’exécution.

Tous ces facteurs réduisent les performances du système. Les groupes de sous-processus surmontez ce problème en gardant les threads vivants et en les réutilisant. Toutes les tâches excédentaires qui passent de quelles sous-processus dans le groupe peuvent gérer sont conservées dans un Queue. Une fois que l’un des threads est libéré, ils occupent la tâche suivante de cette file d’attente. Cette file d’attente de tâches est essentiellement illimitée pour les exécuteurs prêts à être utilisés fournis par la JDK.

Types de exécuteurs

Maintenant que nous avons une bonne idée de ce que c’est un exécuteur exécutif, Prenez également un point sur les différents types d’exécutants.

Singlethreadexececor

Cet exécuteur de groupe de sous-traducs n’a qu’un fil. Il est utilisé pour exécuter des tâches séquentiellement. Si le thread décède en raison d’une exception lors de l’exécution d’une tâche, un nouveau thread est créé pour remplacer l’ancien fil et les tâches suivantes sont exécutées dans le nouveau.

ExecutorService executorService = Executors.newSingleThreadExecutor()

fixeTheadpool (n)

Comme son nom l’indique, il s’agit d’un groupe de sous-processus d’un nombre fixe de sous-processus. Les tâches envoyées à l’exécuteur exécutant sont exécutées par les threads n et s’il y a plus de tâches sont stockées dans un LinkedBlockingQueue. Ce nombre est généralement le nombre total de sous-processus supportés par le processeur sous-jacent.

ExecutorService executorService = Executors.newFixedThreadPool(4);

CachedTheadPool

Ce groupe de sous-processus est utilisé principalement lorsque Il existe de nombreuses tâches parallèles de courte durée à exécuter. Contrairement au groupe de fils fixes, le nombre de sous-processus de ce groupe d’exécuteurs n’est pas limité. Si tous les threads sont occupés à exécuter certaines tâches et une nouvelle marque, le groupe créera et ajoute une nouvelle sous-processus à l’exécuteur exécutante. Dès que l’une des sous-curses est gratuite, elle reprendra l’exécution des nouvelles tâches. Si un fil reste inactif pendant soixante secondes, ils sont finis et retirés du cache.

Cependant, s’il n’est pas administré correctement ou que les tâches ne sont pas de courte durée, le groupe de sous-processus aura beaucoup actif. sous-processus. Cela peut conduire à une élimination des ressources et, par conséquent, à une chute de performance.

ExecutorService executorService = Executors.newCachedThreadPool();

fiscal programmé

Cet exécuteur utilisé il est utilisé quand nous Avoir une tâche à exécuter à intervalles réguliers ou si nous voulons retarder une certaine tâche.

ScheduledExecutorService scheduledExecService = Executors.newScheduledThreadPool(1);

Les tâches peuvent être programmées dans ScheduledExecutor en utilisant l’une des deux méthodes scheduleAtFixedRate ou scheduleWithFixedDelay

scheduledExecService.scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)

scheduledExecService.scheduleWithFixedDelay(Runnable command, long initialDelay, long period, TimeUnit unit)

La principale différence entre les deux méthodes est son interprétation du délai entre les exécutions consécutives de travaux programmés.

scheduleAtFixedRate exécute la tâche avec un intervalle fixe, quelle que soit la tâche précédente terminée.

scheduleWithFixedDelay démarrera le compte à rebours uniquement après la fin de la tâche actuelle.

Comprendre l’objet futur

Vous pouvez accéder au résultat de la tâche envoyée à une exécution à un Executor à l’aide de java.util.concurrent.Future Objet renvoyé par l’exécuteur exécutif. L’avenir peut être considéré comme une promesse faite par l’exécuteur exécutante à l’appelant.

Future<String> result = executorService.submit(callableTask);

Une tâche envoyée à l’exécuteur, comme le précédent, est asynchrone, est asynchrone, est asynchrone, Autrement dit, l’exécution du programme n’attend pas que l’exécution de la tâche passe à l’étape suivante. Au lieu de cela, chaque fois que l’exécution de la tâche est terminée, elle est établie dans cette Future objet par l’albacée.

L’appelant peut continuer à exécuter le programme principal et Lorsque le résultat de la tâche envoyée est nécessaire, vous pouvez appeler .get() dans cet Future objet. Si la tâche est terminée, le résultat est immédiatement renvoyé à l’appelant ou, sinon, l’appelant est bloqué jusqu’à ce que l’exécuteur exécutant achève l’exécution et le résultat est calculé.

si la personne qui appelle peut ne pas se permettre indéfiniment avant Récupération du résultat, cette attente peut également être chronométrée. Ceci est réalisé par la Future.get(long timeout, TimeUnit unit) méthode qui donne un TimeoutException si le résultat n’est pas retourné dans la période stipulée. L’appelant peut gérer cette exception et continuer avec l’exécution ultérieure du programme.

S’il y a une exception lors de l’exécution de la tâche, la méthode GET donnera un ExecutionException.

Quelque chose d’important sur le résultat renvoyé par La méthode est que celle-ci n’est renvoyée que si la tâche envoyée implémente java.util.concurrent.Callable Si la tâche implémente l’interface Runnable, l’appel à .get() retournera

une fois la La tâche est terminée.

Une autre méthode importante est la Future.cancel(boolean mayInterruptIfRunning) méthode. Cette méthode est utilisée pour annuler l’exécution d’une tâche envoyée. Si la tâche est déjà en cours d’exécution, l’exécuteur tentera d’interrompre l’exécution de la tâche si l’indicateur mayInterruptIfRunning Le drapeau est transmis sous .

Exemple: Créez et exécutez une simple exécutante

Nous allons créer une tâche et essayer de l’exécuter dans un exécuteur de groupe fixe:

public class Task implements Callable<String> { private String message; public Task(String message) { this.message = message; } @Override public String call() throws Exception { return "Hello " + message + "!"; }}

l’ID

Implexes de la classeCallableet est paramétré pourStringType. Il est également déclaré en lançantException. Cette capacité à lancer une exception à l’exécuteur exécutante et l’exécuteur qui renvoie cette exception à l’appelant revêt une grande importance car elle aide la personne qui appelle à connaître le statut d’exécution de la tâche.

Nous exécutons maintenant cette tâche:

public class ExecutorExample { public static void main(String args) { Task task = new Task("World"); ExecutorService executorService = Executors.newFixedThreadPool(4); Future<String> result = executorService.submit(task); try { System.out.println(result.get()); } catch (InterruptedException | ExecutionException e) { System.out.println("Error occured while executing the submitted task"); e.printStackTrace(); } executorService.shutdown(); }}

Ici, nous avons créé un FixedThreadPool Exécuteur avec un nombre de 4 threads, car cette démonstration est développée dans un processeur quatre cœurs. Le nombre de sous-processus peut être supérieur aux cœurs du processeur si les tâches exécutées effectuent des opérations d’E / S considérables ou de passer du temps à attendre des ressources externes.

Nous avons instancié le Task classe et prenez-le à l’exécuteur exécutif pour l’exécution. Le résultat est renvoyé par l’objet Future, qui imprime ensuite sur l’écran.

Laissez-nous exécuter et vérifiez votre sortie:

Hello World!

Comme prévu, la tâche ajoute le message « Bonjour » et renvoie le résultat à travers le Future objet.

Enfin, nous appelons au moment de l’objet executorService objet pour terminer toutes les discussions et renvoyer les ressources au système d’exploitation.

Le .shutdown() La méthode est actuellement l’achèvement des tâches actuellement envoyées à l’exécuteur exécutante. Toutefois, si l’exigence ferme immédiatement l’exécuteur sans attendre, nous pouvons utiliser .shutdownNow() Méthode en place.

Toute tâche d’exécution en attente sera renvoyée dans un java.util.List objet.

En outre, nous pouvons créer cette même tâche en implémentant l’interface Runnable

public class Task implements Runnable{ private String message; public Task(String message) { this.message = message; } public void run() { System.out.println("Hello " + message + "!"); }}

Il y a une paire Des changements importants ici lorsque nous mettons en œuvre runnable.

Le résultat de l’exécution de la tâche ne peut pas être renvoyé à partir de la run() méthode. Par conséquent, nous imprimons directement d’ici.
L’ID

La méthode n’est pas configurée pour lancer une exception marquée.

Conclusion

Le sous-processus multiple devient de plus en plus courant car la vitesse de l’horloge du processeur est difficile à augmenter. Cependant, la manipulation du cycle de vie de chaque thread est très difficile en raison de la complexité impliquée.

Dans cet article, nous avons démontré un cadre multiple multiple mais simple, un cadre exécuteur exécutant et expliqué ses différents composants. Nous examinons également différents exemples de création et d’exécution de tâches dans un exécuteur exécutante.

Comme toujours, le code de cet exemple peut être trouvé dans GitHub.

Java Concurrence: Cadre d’exécution