Pool de threads Java

Un pool de threads, comme son nom l'indique, est un ensemble de threads qui peuvent être réutilisés. Ces threads ont été créés précédemment et peuvent également fonctionner en offrant une solution aux frais généraux lorsqu'une collection de threads est déjà disponible ; ceux-ci peuvent être réutilisés et résoudre le problème des cycles de thread et de l'attente que les threads terminent leur tâche. Comme le thread existera déjà chaque fois que la demande arrivera, il supprimera le processus de création du thread et, par conséquent, gagnera du temps et accélérera le traitement. Dans cette rubrique, nous allons découvrir Java Thread Pool.

Commencez votre cours de développement de logiciels libres

Développement Web, langages de programmation, tests de logiciels et autres

Fonctionnement du pool de threads Java

Tous les threads des pools de threads implémentent les méthodes de java.util.concurrent. Il existe un pool de threads géré par le pool de threads Java. La façon la plus simple de voir ce pool est que plus vous utilisez de threads, moins chaque thread passera de temps à effectuer le travail réel. C'est un moyen qui permet d'économiser des ressources dans une application où le multithreading peut être utilisé. Il existe une file d'attente qui est maintenue par ce thread Java pour les pools.

Les threads de travail attendent que les tâches soient assignées et les exécutent. Pour créer un pool de threads, ThreadPoolExecutor est utilisé en Java. La collection de threads exécutables est responsable de la gestion des threads dans le pool de threads Java. Après cela, les threads de travail apparaissent sous forme d'image et forment des files d'attente. Le pool de threads surveille ces files d'attente.

Les java.util.concurrent.Executors nous aident avec les méthodes d'usine et de support nécessaires à la gestion des threads. Cette classe est également responsable de la création du pool de threads. Maintenant, votre prochaine question pourrait être : quel est cet exécuteur ? Executor fournit différentes classes qui font partie de la classe utilitaire.

Le fonctionnement technique du pool de threads peut être considéré comme un pool dans lequel vous disposez de votre code concurrent, qui est divisé en tâches pouvant s'exécuter en parallèle. Ensuite, ils sont soumis pour exécution au pool. Il existe des soumissionnaires de tâches, des services d'exécution, des files d'attente de tâches et, en fin de compte, le pool de threads. Le modèle peut vous aider à contrôler le nombre de threads présents dans l'application. Il décide de son cycle de vie, planifie les tâches et conserve les tâches entrantes dans la file d'attente des travaux.

La classe Executorshelper dispose de diverses méthodes qui ont des instances de pool de threads préconfigurées. Les interfaces Executor et ExecutorService aident à travailler avec différentes implémentations dans le pool. Le code doit être au format découplé avant la mise en œuvre effective. Il existe une autre interface utilisée. C'est un ThreadPoolExecutor. Il s'agit d'une implémentation de pool de threads extensible dans laquelle de nombreux paramètres peuvent être spécifiés, ce qui entraînera un réglage fin. Les paramètres pouvant être utilisés incluent la taille du pool principal, la taille maximale du pool et la durée de conservation. La file d'attente ne peut augmenter que jusqu'à la taille maximale du pool.

Exemple de pool de threads Java

Créons un pool et voyons comment cela fonctionne.

Code :

import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
// The Job class will be executed in this case
class Job implements Runnable
{
private String name;
public Job(String s)
{
name = s;
}
// The task name will be populated first for the ones which were not running already, and the thread will sleep for 2s
//This entire method will be repeated 6 times
public void run()
{
try
{
for (int i = 0; i<=5; i++)
{
if (i==0)
{
Date d = new Date();
System.out.println("We are in "
+ " task name - "+ name);
//prints the task name every time the new task is started
}
else
{
System.out.println("The job "+
name +" is already running ");
// prints the job name which is already running
}
Thread.sleep(2000); // The thread is in sleep mode for 2 secs
}
System.out.println(name+" job is completes");
}
catch(InterruptedException e)
{
e.printStackTrace();
}
}
}
public class Test
{
// Here we define the maximum threads we have
static final int MAX_Threads= 5;
public static void main(String[] args)
{
Runnable run1 = new Job("task 1");
Runnable run2 = new Job("task 2");
Runnable run3 = new Job("task 3");
//A new thread pool is created with maximum number of threads
ExecutorService newpool = Executors.newFixedThreadPool(MAX_Threads);
newpool.execute(run1);
newpool.execute(run2);
newpool.execute(run3);
newpool.shutdown();
}
}

Le code ci-dessus couvre chaque étape de la création du thread jusqu'à son arrêt. Il existe une limite maximale de threads fixée et créée. Une fois cela fait, trois tâches sont créées qui s’exécutent une par une. Il y a également un temps de sommeil alloué de 2 secondes pour chaque tâche. Au fur et à mesure que le pool de threads est créé et que tous les travaux fonctionnent simultanément, nous pouvons voir que l'ensemble de ce processus s'exécutera 6 fois. Lorsque l'instruction if s'exécute dans le pool de threads, elle vérifie si le travail est déjà en cours d'exécution ou non. Si le travail n’a pas commencé à s’exécuter, il exécutera le bloc if. S'il est déjà en cours d'exécution, le bloc else sera exécuté. Il affichera le nom du travail et indiquera qu'il est déjà en cours d'exécution. Le pool de threads est créé, puis les 3 tâches sont exécutées. Une fois les tâches exécutées, nous arrêtons le pool de threads que nous avons créé.

Ci-dessous se trouve la sortie du programme donné.

Sortie :

Il s'exécute jusqu'à ce que toutes les tâches soient terminées.

Avantages et inconvénients des pools de threads

Nous avons plusieurs avantages du Thread Pool en Java. Pour n'en citer que quelques-uns, voici les principaux avantages :

• Il en résulte des performances meilleures et plus efficaces du processeur et du programme.
• Comme différents threads exécutent tous les processus, cela fait gagner du temps.
• Le principal avantage du pool de threads est la réutilisation des threads déjà présents. Il n'est pas nécessaire de créer de nouveaux fils de discussion encore et encore.
• Il fournit un accès en temps réel, ce qui facilite le travail avec des données en temps réel.

Nous avons cependant également quelques inconvénients du pool de threads. Voici les inconvénients :

• Vous ne pouvez pas définir la priorité des tâches, et celles-ci ne peuvent pas non plus être suivies.
• Lorsqu'ils sont utilisés davantage, ceux-ci peuvent être supprimés automatiquement.

Conclusion

En conséquence, les pools de threads sont un moyen efficace de gérer les multiples tâches que nous avons à notre disposition. Java nous offre la possibilité de réutiliser les threads et d'utiliser les ressources existantes.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!