Comme nous le savons, un processus est un programme en cours d’exécution tandis qu’un thread est un semi-processus ou un processus léger.
Dans ce tutoriel, nous allons discuter de ce qu’est un processus multithread. De plus, nous allons apprendre pourquoi il y a une limite au nombre de threads par processus sous Linux et quelle est cette limite.
Qu’est-ce qu’un processus Multithread ?
La fourniture de plusieurs threads d’exécution au sein d’un même programme dans un espace mémoire partagé est appelée multithreading.
Un processus multithread nous permet d’exécuter plusieurs threads simultanément. Le but du multithreading est d’augmenter les performances.
Pour des performances optimales, Linux a une limite sur le nombre de threads. Le paramètre threads-max kernel peut être défini pour s’assurer que le nombre de threads par processus est toujours inférieur ou égal à cette limite. Cependant, d’autres facteurs tels que la quantité de mémoire virtuelle et la taille de la pile peuvent indirectement régir le nombre de threads alloués à un processus.
Limite du nombre de Threads par processus
Linux a un paramètre pour le nombre maximal de threads par processus, qui spécifie le nombre maximal d’exécutions simultanées que le processus peut gérer.
Les modifications apportées peuvent accélérer le processus et minimiser les latences pour les exécutions qui se produisent.
Atteindre cette limite signifie que le processus a besoin d’autant de threads à la charge maximale. Mais, tant qu’il peut répondre aux demandes en temps opportun, le processus est correctement réglé.
Cependant, lorsque la limite est atteinte, les threads se mettent en file d’attente, surchargeant potentiellement le processus. À ce stade, le processus reporte la création de nouveaux threads jusqu’à ce que le nombre de threads actifs tombe en dessous de la limite.
Comment Récupérer le Nombre Maximum de Threads
Le paramètre threads-max du noyau contrôle le nombre maximum de threads.
freestar
Ce paramètre est défini dans le fichier /proc/sys/kernel/threads-max.
Affichons ce fichier à l’aide de la commande cat:
catcat/proc/sys/noyau/threads – max
63704
Ici, la sortie 63704 indique que le noyau peut exécuter un maximum de 63 704 threads.
Alternativement, nous pouvons utiliser la commande sysctl pour récupérer la valeur threads-max:
threads fils sysctl-a|grep – max
noyau.fils – max = 63704
noyau.pid_max et vm.max_map_count spécifie deux autres limites qui bloqueront également la création du nouveau thread à la charge maximale.
freestar
Le paramètre pid_max spécifie la valeur à laquelle les PID s’enroulent:
catcat/proc/sys/noyau/pid_max
131072
Noyau.la valeur pid_max de 131072 ci-dessus signifie que le noyau peut exécuter un maximum de 131 072 processus simultanément.
Le paramètre max_map_count spécifie le nombre maximal de zones de mémoire virtuelle (VMA) qu’un processus peut posséder:
$cat/proc/sys/vm/max_map_count
65530
La vm.la valeur max_map_count de 65530 ci-dessus est le nombre maximum de zones de carte mémoire qu’un processus peut avoir.
Le noyau Linux gère à la fois un processus et un thread de la même manière. Ainsi, les valeurs limitant le nombre de processus limiteront indirectement également le nombre de threads.
Par conséquent, le noyau.pid_max doit être supérieur au nombre total de threads et de processus simultanés.
Avoir de nombreux threads peut consommer trop de mémoire pour que le serveur fonctionne. vm.max_map_count limite à la fois la mémoire virtuelle et le nombre de threads qui nécessitent cette mémoire pour configurer leur propre pile privée.
Sur les systèmes systemd, les cgroup pids.le paramètre max applique une autre limite. Cette valeur est définie sur 12 288 par défaut. À certaines occasions, cette limitation des ressources par défaut n’est pas suffisante, ou peut-être trop restrictive.
freestar
Alternativement, effectuer des ajustements spécifiques sur certains des paramètres TasksMax de systemd peut s’avérer utile. Le paramètre UserTasksMax dans la section [Login] de /etc/systemd/logind.conf remplace la limite par défaut:
gregrep-i « ^UserTasksMax » /etc/systemd/logind.conf
UserTasksMax = 50000
C’est exactement ainsi que systemd applique également une limite de threads pour les programmes exécutés à partir d’un shell de connexion.
Comment Définir le Nombre Maximum de Threads
Il existe plusieurs façons de définir la valeur pour le nombre maximum de threads par processus. Ces valeurs déterminent le nombre de threads autorisés par un processus.
Définissons temporairement le paramètre de noyau threads-max à l’exécution:
echoecho 120000 >/proc/sys/noyau/threads – max
Nous pouvons définir définitivement le noyau.threads – paramètre max en ajoutant le noyau.threads-max= dans le fichier /etc/sysctl.fichier de configuration:
kernel noyau sysctl-w.threads – max= 120000 >>/etc/sysctl.conf
Ensuite, la définition du paramètre pid_max à 200000 signifie que le noyau peut exécuter un maximum de 200 000 processus simultanément:
echoecho 200000 >/proc/sys/noyau/pid_max
De même, la définition du paramètre max_map_count à 600000 signifie qu’un processus peut posséder un nombre maximum de 600 000 zones de mémoire virtuelle (VMA):
echoecho 600000 > /proc/sys/vm/max_map_count
Sur les systèmes systemd, UserTasksMax spécifie le paramètre TasksMax pour tous les utilisateurs et détermine la limite de thread:
$sed-i « s/^UserTasksMax/#UserTasksMax/ »/etc/systemd/system.conf
echo echo « UserTasksMax=60000 » >> /etc/systemd/system.conf
gregrep-i « UserTasksMax » /etc/systemd/logind.conf
UserTasksMax = 50000
UserTasksMax = 60000
Facteurs Qui Affectent Le Nombre Maximal De Threads
Bien qu’il existe des paramètres système qui fixent une limite au nombre de threads par processus, le système d’exploitation et la mémoire deviennent probablement les facteurs limitatifs bien avant cela.
La limite du nombre de threads qu’un processus peut avoir est calculée à l’aide de la formule:
nombre de threads = mémoire virtuelle totale / (taille de la pile * 1024 * 1024)
Ainsi, le nombre de threads par processus peut être augmenté en augmentant la mémoire virtuelle totale. La quantité de taille de pile par thread est plus susceptible d’être la limite qu’autre chose. Réduire la taille de la pile par thread est également un moyen d’augmenter le nombre total de threads.
Nous pouvons vérifier la taille de la pile par thread avec ulimit:
sizeulimit-a|grep « taille de la pile »
taille de la pile (kbytes, -s) 10240
La valeur signifie que chacun des threads recevra cette quantité de mémoire (10 Mo) affectée à sa pile. Avec un programme 32 bits et un espace d’adressage maximal de 4 Go, le nombre maximum de threads sera:
4096 Mo / 10 Mo = 409
Sur un processeur 64 bits, nous pouvons ajuster la taille de la pile par thread avec ulimit:
freestar
$ ulimit-s 8192
Conclusion
Dans cet article, nous avons compris ce qu’est un processus multithread sous Linux. Nous avons également appris l’importance du nombre maximum de threads par nombre de processus sous Linux. Enfin, nous avons vu comment récupérer et définir le nombre maximal de threads par nombre de processus et les facteurs qui l’affectent.