Le pool de threads est un outil pratique pour collecter des tâches en parallèle. Avec l'introduction d'architectures multi-core adaptées à la parallélisation des applications, le rôle des pools de threads devient de plus en plus apparent. Grâce à la classe ThreadPoolExecutor et à d'autres classes auxiliaires, Java 5 a présenté ce cadre en tant que nouvelle section de support de concurrence.
Le framework ThreadPoolExecutor est flexible et puissant. Il prend en charge les configurations spécifiques à l'utilisateur et fournit des crochets et des politiques de saturation pertinents pour gérer les files d'attente complètes.
Le pool de threads Java placera d'abord les tâches soumises dans la file d'attente de travail et les obtiendra de la file d'attente de travail (SynchronousQueue est soumise directement par le producteur au thread de travail). Ensuite, il existe deux stratégies de mise en œuvre pour les files d'attente de travail: les files d'attente illimitées et les files d'attente délimitées. Il n'y a aucun problème avec la saturation dans la file d'attente illimitée, mais le problème est que lorsque la demande continue d'être élevée, la tâche sera ajoutée à la file d'attente de travail sans cervelle, ce qui peut entraîner un débordement ou d'échappement de la mémoire et d'autres ressources. Les files d'attente limitées ne provoqueront pas d'épuisement de mémoire causée par une charge élevée, mais il y a un problème sur la façon de gérer les tâches nouvellement soumises lorsque la file d'attente de travail est pleine. C'est le problème que la stratégie de saturation de file d'attente de file de pool de fil doit résoudre.
Les stratégies de saturation sont divisées en: stratégie d'abandon, stratégie Calerruns, élimination de la stratégie et stratégie de défaillance.
Pour une meilleure compréhension, j'ai écrit un petit exemple.
package concurrency.pool; importer java.util.concurrent.linkedblockingdequ; import java.util.concurrent.rejecdexecutionhandler; import java.util.concurrent.threadpoolExecutor; Différentes politiques de saturation * @param handler thread pool work work filed saturation Politique * / public static void Politique (rejettedexEcutionHandler Handler) {// il y a 2 threads de base, le nombre maximum de threads est de 3 et la capacité de file d'attente de travail est 5. ThreadPoolExecutor Exec = new ThreadPoolexECUTOR (2,3,0l, timeunit.Milliseconds, new LinkedBlockingDeque <> (5)); if (Handler! = Null) {exec.setrejectEdExecutionHandler (Handler); // Set Saturation Policy} pour (int i = 0; i <10; i ++) {exec.submit (new task ()); // soumettre la tâche} exec.shutdown ();} public static Void Main (String [] args) {// la police (nouvelle stratégie (nouvelle strate ThreadPoolExecutor.AbortPolicy ()); // Politique ((nouvelle stratégie ThreadPoolExecutor.CallerSpolicy ())); // Politique (nouveau ThreadPoolExecutor.DiscardPolicy ()); id = 0; // tâche id public task () {id = ++ count;} @ override public void run () {try {timeunit.seconds.sleep (3); // sommeil pendant 3 secondes} catch (interruptedException e) {System.err.println ("Thread a été interrompu" + e.getMessage ();} System.out.out.printLn ("Tâche:" id + " Thread: "+ thread.currentThread (). getName () +" Exécution terminée ");}}} Lorsque la file d'attente de travail est pleine, les différentes stratégies sont gérées comme suit:
1. Politique ABORT: stratégie par défaut. Lorsqu'une nouvelle tâche est soumise, l'exception non contrôlée est directement lancée. L'exception peut être capturée par l'appelant.
Ajoutez le code suivant à la fonction principale:
politique (new ThreadPoolExecutor.AbortPolicy ());
Le résultat de l'opération est:
Le programme lance une rejette de rejetExutionException, et un total de 8 tâches sont exécutées (le pool de threads peut exécuter 3 tâches au début, et 5 files d'attente sont stockées dans la file d'attente de travail). Lorsque la file d'attente de travail est pleine, une exception est directement lancée et le JVM ne sort pas (je ne sais pas pourquoi maintenant). Nous pouvons voir que tous les threads qui exécutent des tâches sont des threads dans le pool de threads.
2. Stratégie de Calerruns: pour le mécanisme d'ajustement, ni abandonner les tâches ni lancer des exceptions, mais retomber à l'appelant. La nouvelle tâche n'est pas exécutée dans le pool de threads, mais dans le thread appelant l'expector.
Exécutez dans la fonction principale:
politique ((new ThreadPoolExecutor.CallerRunspolicy ()));
Résultats en cours d'exécution
Toutes les tâches sont exécutées et 2 (10 - 3 -5) les tâches sont exécutées avec succès dans le thread principal, et 8 tâches sont exécutées par des threads dans le pool de threads.
3. Stratégie de discard: les tâches nouvellement soumises sont abandonnées.
Exécuter en fonction principale
politique (new ThreadPoolExecutor.DiscardPolicy ());
Les résultats ci-dessus montrent qu'aucune exception n'est lancée, les 2 nouvelles tâches soumises plus tard sont rejetées et seules les 8 premières tâches (3 + 5) sont traitées et les sorties JVM.
4.Discardold le plus: la file d'attente est la tâche du "chef de l'équipe", puis essayez de soumettre une nouvelle tâche. (Pas adapté aux scénarios de file d'attente de travail comme files d'attente prioritaires)
Exécutez la méthode suivante dans la fonction principale
politique (new ThreadPoolExecutor.DiscardolDestPolicy ());
Résultat de course: il y a 8 tâches en cours au total. Le programme se termine. Les tâches ajoutées plus tard sont de 9 et 10, tandis que les tâches précédentes 3 et 4 sont jetées.
Résumer
Ce qui précède est l'intégralité du contenu de cet article sur l'exemple de code de la stratégie de saturation de la file d'attente de filetage de thread Java. J'espère que ce sera utile à tout le monde. S'il y a des lacunes, veuillez laisser un message pour le signaler. Merci vos amis pour votre soutien à ce site.