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.