Le pool de threads est en fait une implémentation de la technologie de pooling. L'idée principale de la technologie de pooling est de réaliser la réutilisation des ressources et d'éviter les frais généraux de performances causés par la création et la destruction répétées de ressources. Le pool de threads peut gérer un groupe de threads afin que les threads ne soient pas détruits une fois la tâche terminée, mais continuent à traiter les tâches qui ont été soumises par d'autres threads.
Avantages de l'utilisation du pool de threads
Réduisez la consommation de ressources. Réduisez le coût de création et de destruction des threads en réutilisant les threads créés.
Améliorer la vitesse de réponse. Lorsqu'une tâche arrive, elle peut être exécutée immédiatement sans attendre la création du thread.
Améliorer la gestion des threads. Les threads sont des ressources rares. S'ils sont créés sans restrictions, ils consommeront non seulement des ressources système, mais réduiront également la stabilité du système. Le pool de threads peut être utilisé pour une allocation, un réglage et une surveillance unifiés.
Paramètres de construction
corePoolSize : utilisé pour travailler dans le pool de threadsNombre de threads principaux。
taille maximale du pool :Nombre maximum de threads , le nombre maximum de threads pouvant être créés par le pool de threads. Lorsque le nombre de threads dans le pool de threads atteint corePoolSize, si la file d'attente des tâches est pleine et que de nouvelles tâches doivent être traitées, le pool de threads créera de nouveaux threads (mais le nombre total ne dépasse pas maximumPoolSize) pour traiter ces tâches. (Cela équivaut à lorsque la zone de file d'attente est pleine, les threads suivants peuvent directement accéder à la file d'attente.) Si le nombre de tâches dépasse maximumPoolSize et que la file d'attente des tâches est pleine, le pool de threads traitera ces tâches non exécutables conformément à la politique de rejet.
keepAliveTime : la durée de survie des threads créés après avoir dépassé corePoolSize ou tous les threadsDurée de survie maximale, selon la configuration.
unité : keepAliveTimeunité de temps。
file d'attente de travail :file d'attente des tâches , est une file d'attente de blocage. Lorsque le nombre de threads atteint le nombre de threads principaux, la tâche sera stockée dans la file d'attente de blocage. Implémentations courantes : classes d'implémentation de l'interface BlockingQueue, telles que ArrayBlockingQueue, LinkedBlockingQueue, etc.
threadFactory : utilisé pour créer des threads dans le pool de threadsusine。
gestionnaire：Politique de refus;Lorsque la file d'attente est pleine et que le nombre de threads atteint le nombre maximum de threads, cette méthode sera appelée pour traiter la tâche.
Comment définir les paramètres
1. Déterminez le nombre de threads principaux (corePoolSize)
Tâches gourmandes en CPU : pour les tâches gourmandes en CPU, il est courant de définir le nombre de threads principaux entre 1 et 2 fois le nombre de cœurs de CPU. Cela garantit une utilisation complète des ressources du processeur tout en évitant des changements de contexte excessifs.
Tâches gourmandes en E/S : pour les tâches gourmandes en E/S, étant donné que les threads n'occupent pas le processeur en attendant les opérations d'E/S, davantage de threads principaux peuvent être définis. De manière générale, le nombre de threads principaux peut être défini à plus de 2 fois le nombre de cœurs de processeur afin que davantage de tâches puissent être traitées en attendant les E/S.
Tâches mixtes : si votre application contient à la fois des tâches gourmandes en CPU et en E/S, vous devez équilibrer les paramètres du nombre de threads principaux en fonction de la situation spécifique.
2. Déterminez le nombre maximum de threads (maximumPoolSize)
Environnements aux ressources limitées : dans les environnements aux ressources limitées (tels que les systèmes embarqués ou les serveurs cloud), le nombre maximum de threads doit être limité pour éviter qu'un trop grand nombre de threads n'occupent les ressources.
Système à haute concurrence : pour les systèmes qui doivent gérer un grand nombre de requêtes simultanées, le nombre maximum de threads peut être augmenté de manière appropriée pour améliorer les capacités de traitement simultané du système. Cependant, la définition du nombre maximum de threads doit être prise en compte de manière globale en fonction de la capacité de charge et des conditions de ressources du système.
3. Définir le temps d'inactivité du thread (keepAliveTime)
Applications gourmandes en CPU : pour les applications gourmandes en CPU, vous pouvez généralement définir le temps d'inactivité des threads sur une valeur plus courte, car les ressources du processeur sont très précieuses et vous ne souhaitez pas que trop de threads inactifs occupent des ressources. Dans certains cas, il peut même être fixé à 0, indiquant que les threads non essentiels ne sont pas conservés.
Applications gourmandes en E/S : pour les applications gourmandes en E/S, étant donné que les threads n'occupent pas de ressources CPU lorsqu'ils attendent des opérations d'E/S, le temps d'inactivité du thread peut être défini sur une valeur plus longue (par exemple plus d'une minute) pour éviter le démarrage et la destruction fréquents des threads. . la surcharge de performances provoquée.
4. Sélectionnez la file d'attente des tâches (workQueue)
file d'attente délimitée : L'utilisation d'une file d'attente limitée peut limiter le temps d'attente des tâches dans la file d'attente et éviter un débordement de mémoire dû à un trop grand nombre de tâches. Cependant, si la longueur de la file d'attente est trop petite, les tâches peuvent être rejetées. (Choisissez généralement une file d'attente limitée）
File d'attente illimitée : l'utilisation d'une file d'attente illimitée peut mettre en cache toutes les tâches autant que possible, mais vous devez faire attention aux problèmes de consommation de mémoire. Si une file d'attente illimitée est utilisée, le paramètre de nombre maximal de threads du pool de threads peut devenir non valide car le pool de threads ne tente pas de créer de nouveaux threads pour traiter les tâches dans la file d'attente.
5. Configurer la fabrique de threads (threadFactory)
La fabrique de threads est utilisée pour créer de nouveaux threads. En personnalisant la fabrique de threads, vous pouvez définir des attributs tels que la priorité des threads et l'état des threads du démon, et vous pouvez également définir des noms significatifs pour les threads afin de faciliter le diagnostic des problèmes dans la JVM.
6. Configurer la politique de rejet (gestionnaire)
Lorsque le pool de threads ne peut pas traiter de nouvelles tâches (c'est-à-dire que le nombre de threads a atteint maximumPoolSize et que la file d'attente des tâches est pleine), une politique de rejet doit être configurée pour gérer ces tâches non exécutables.Les stratégies de rejet courantes incluentLancer une exception directement、Utilisez le fil de l'appelant pour exécuter la tâche、Ignorer les nouvelles tâches et supprimer les tâches les plus anciennes de la file d'attente attendez. Vous pouvez également personnaliser la politique de rejet selon vos besoins.
