Comment lister et contrôler en détail les LWP et les processus sous Linux

Si vous administrez des serveurs ou travaillez fréquemment sous Linux, vous aurez tôt ou tard besoin de lister les processus, les threads légers (LWP) et de surveiller leur consommation de ressources . Savoir ce qui est en cours d'exécution, les ressources utilisées et l'organisation de chaque processus est essentiel pour détecter les goulots d'étranglement, les interruptions de service ou les comportements anormaux du système.

Vous trouverez ci-dessous un guide complet expliquant ce que sont les processus et les LWP, comment les lister, comment consulter leurs limites et comment les surveiller en temps réel . Nous utiliserons les commandes classiques (ps, top, htop, etc.) comme base, ainsi que des techniques plus avancées avec /proc, les outils de diagnostic et les paramètres de priorité, le tout expliqué en espagnol clair et simple.

Processus, threads et LWP sous Linux : concepts de base

Sous Linux, lorsqu'on exécute un programme, un processus est créé. Il s'agit de l'instance de ce programme en mémoire , avec toutes les ressources nécessaires : code, données, descripteurs de fichiers, pile, etc. Chaque processus reçoit un identifiant unique appelé PID (Process ID), qui est le numéro utilisé pour le surveiller ou l'arrêter.

Outre les processus « normaux » ou lourds, le noyau gère les processus légers (LWP) . Un LWP partage une part importante de ressources (code, données, fichiers ouverts, signaux, etc.) avec d'autres threads du même processus, mais conserve sa propre pile et son propre contexte d'exécution. Cela rend le changement de contexte entre threads beaucoup plus rapide que le changement de contexte entre processus indépendants.

Une particularité de Linux est qu'en interne, il ne fait pas de distinction stricte entre un processus et un thread : les deux sont gérés comme des tâches du noyau, et un thread est essentiellement un « processus » qui partage des ressources avec d'autres. Il n'existe pas de structures de threads spécifiques au niveau du noyau comme dans d'autres systèmes d'exploitation , bien qu'en pratique, on puisse utiliser des LWP pour obtenir un véritable parallélisme sur les systèmes multicœurs.

Ce parallélisme est obtenu en répartissant la charge de travail d'une application sur plusieurs threads. Chaque LWP peut s'exécuter sur un cœur de processeur différent , permettant ainsi au programme d'utiliser tous les cœurs disponibles. Le coût de création et de changement de LWP étant faible, Linux est très performant pour l'exécution d'un grand nombre de threads, à condition de respecter les limites du système.

Limites de processus et de threads sous Linux

Comme pour tout système d'exploitation, le noyau ne peut traiter simultanément qu'un nombre maximal de tâches. Sous Linux, ces tâches sont limitées. Les limites des processus et des threads sont exposées comme paramètres du noyau au sein du pseudo-système de fichiers /proc, sur le parcours /proc/sys/kernel/.

La limite globale du nombre de threads que le noyau peut prendre en charge est stockée dans le fichier /proc/sys/kernel/threads-maxSi vous vérifiez le contenu de ce fichier avec cat o sysctlVous obtiendrez le nombre maximal de LWP que le système est capable de créer avant de refuser de lancer d'autres tâches.

Cette valeur est généralement assez élevée sur les serveurs modernes dotés de plusieurs cœurs et d'une grande quantité de RAM, tandis que sur des machines plus modestes ou de petites machines virtuelles , elle peut être plus faible. Si cette limite est atteinte et qu'aucun processus ne se termine, le noyau ne pourra plus créer de nouveaux processus ni de nouveaux threads, ce qui peut entraîner des erreurs lors du lancement de services ou de commandes.

Il existe une autre limite importante dans /proc/sys/kernel/pid_maxCela indique l'identifiant de processus maximal pouvant être attribué. Cette valeur limite également le nombre de processus (et par extension, de threads) pouvant coexister, Linux les traitant de manière unifiée. Lorsque le compteur de PID atteint ce maximum, il redémarre à zéro, et il est fréquent d'observer des PID « répétés ». le tempsmais appartenant à des processus complètement différents.

Calcul du nombre maximal de threads et ajustement de la pile

Le nombre réel de LWP (Low-Write Processing) que vous pouvez exécuter sur un système Linux dépend non seulement des paramètres du noyau, mais aussi de la mémoire virtuelle disponible et de la taille de la pile de chaque thread . Une formule approximative couramment utilisée est :

nombre maximal de threads ≈ mémoire virtuelle / (taille de la pile × 1024 × 1024)

Dans cette expression, la taille de la pile par thread est généralement interrogée avec la commande ulimit -sCette valeur indique le nombre de kilo-octets de mémoire réservés à la pile de chaque LWP créé. Une taille de pile plus importante offre une meilleure protection contre les débordements, mais aussi Vous pourrez avoir moins de threads simultanés. pour la même quantité de mémoire.

Si vous avez besoin d'exécuter une application avec des milliers, voire des dizaines de milliers de threads, cela pourrait vous intéresser. réduire la taille de la pile par thread en utilisant à nouveau ulimit (par exemple dans les scripts de Botte ou services système), à ​​condition que le code de l'application ne nécessite pas de piles énormes.

En résumé, le nombre de processus LWP sous Linux est limité par les paramètres du noyau (threads-max, pid_max), la taille de la pile par thread et la mémoire totale disponible . En ajustant judicieusement ces facteurs, il est possible d'augmenter le nombre de threads simultanés sans compromettre la stabilité du système.

Commandes de base pour lister les processus et les LWP

Pour commencer à travailler avec les processus et les threads sous Linux, l'outil classique est la commande ps, qui indique l'état des processus Il s'agit d'un instantané (et non d'une image en temps réel). Contrairement à un moniteur graphique, son affichage est statique : pour obtenir des informations mises à jour, il suffit de le redémarrer.

Avec ps aucune option Vous ne verrez que les processus liés à l'interpréteur de commandes actuel. Pour obtenir tous les processus du systèmey compris ceux qui n'ont pas terminal En général, on utilise plutôt :

ps aux

Ce résultat affiche, entre autres données, l'utilisateur propriétaire, le PID, le pourcentage d'utilisation du processeur et de la RAM, la durée d'exécution et la commande utilisée pour lancer chaque processus. C'est une quantité importante d'informations, mais essentielle pour identifier les tâches qui consomment une grande partie des ressources de la machine.

Quelques combinaisons utiles de ps Pour mieux contrôler ce qui apparaît, les éléments suivants sont utilisés :

• ps -e o ps -A: liste tous les processus actifs au format générique UNIX.
• ps -u nombre_usuario: affiche uniquement les processus d'un utilisateur spécifique.
• ps -axjf: affiche le résultat dans un format hiérarchique, en imbriquant les processus enfants sous leurs parents.
• ps -C nombre_proceso: filtre par nom de commande et inclut les processus enfants associés.

Une autre option courante consiste à utiliser ps aux | grep patrón ne conserver que les processus contenant ce texte, par exemple un démon web, un moteur de base de données ou un scénario Concrètement, c'est un moyen très pratique de trouver en un coup d'œil ce que vous cherchez, sans se perdre dans des pages et des pages de résultats.

Surveillance en temps réel avec top et htop

Lorsque vous avez besoin de voir comment les processus évoluent en temps réel, la commande étoile est top, qui affiche un moniteur dynamique de l'activité du système. Contrairement à psLes résultats sont mis à jour en continu et affichent l'utilisation du processeur, l'utilisation de la mémoire, la charge moyenne, le nombre de tâches actives et une liste ordonnée des processus.

En courant simplement topVous verrez les processus classés par utilisation du processeur. Vous pouvez Réorganiser selon d'autres champs, filtrer, arrêter des processus ou modifier les priorités en appuyant sur différentes touches au sein de l'interface elle-même (les combinaisons peuvent varier légèrement selon la version, mais sont généralement indiquées en bas).

Une méthode courante pour se concentrer sur les processus les plus gourmands en ressources consiste à utiliser une commande comme :

top -o %CPU

De cette façon, vous placez en haut les processus qui consomment le plus de ressources CPU , ce qui est très utile lorsqu'un processus provoque une augmentation soudaine de l'utilisation du processeur et que vous souhaitez trouver rapidement le coupable.

Si vous préférez quelque chose de plus visuel, vous pouvez installer htop, une version améliorée de top avec une interface interactiveBarres de couleur et navigation au clavier et à la souris. Sur de nombreuses distributions, vous devrez d'abord l'installer à l'aide du gestionnaire de paquets, par exemple :

sudo apt-get install htop

Une fois installé, vous exécutez htop et vous aurez une vue codée par couleur de la charge par cœur, de la mémoire, du swap et un tableau des processus où vous pourrez Défilez verticalement et horizontalement, filtrez par utilisateur, modifiez les priorités ou arrêtez les processus sans saisir manuellement le PID..

Surveillance des ressources avec atop

Pour une analyse des performances plus approfondie, notamment sur les serveurs, il existe l'outil atop, qui enregistre et affiche l'activité de tous les processus avec un niveau de détail élevé. Il s'agit d'un utilitaire plein écran en mode texte qui se concentre sur l'évolution de la charge et de l'utilisation des ressources au fil du temps.

Quand tu lances atopVous verrez des statistiques de Processeur, mémoire, espace d'échange, disques et réseau Ces données s'actualisent généralement toutes les 10 secondes. De plus, le système peut rester actif en arrière-plan pendant plusieurs jours, conservant ainsi un historique que vous pourrez consulter ultérieurement pour analyser un problème survenu par le passé.

Parmi ses avantages, citons la possibilité de regrouper la consommation par utilisateur ou par nom de processus , de mettre en évidence en rouge les ressources critiques qui s'épuisent, d'afficher les processus qui sont déjà terminés mais qui sont toujours pertinents dans le journal et de surveiller les threads internes (LWP) au sein de chaque processus.

Dans de nombreuses distributions, il est installé avec des paquets spécifiques ; par exemple :

sudo apt install atop
sudo dnf install atop

Après l'installation, il suffit d'exécuter atop pour commencer à observer au niveau du processus la consommation du processeur, de la mémoire, du disque et du réseau, et ainsi pouvoir détecter avec une précision considérable quel composant sature le système.

Comment afficher le nombre de threads (LWP) par processus

Si ce qui vous intéresse, c'est de savoir combien Les fils légers nécessitent un procédé spécifique.Linux offre plusieurs méthodes pour obtenir ces informations. La première consiste à inspecter le système de fichiers virtuel. /proc, où le noyau expose des données internes pour chaque tâche.

Dans /proc/<PID>/ vous trouverez le fichier status, qui comprend le champ ThreadsEn lisant ce fichier, vous pouvez rapidement voir combien de LWP le processus avec ce PID particulier a créés, ainsi que de nombreux autres détails tels que l'état, la consommation de mémoire et les capacités.

Une autre façon d'utiliser /proc Il s'agit d'examiner le contenu du répertoire /proc/<PID>/task/Dans ce chemin, le noyau crée un sous-répertoire pour chaque thread appartenant au processus. Ainsi, nombre de répertoires dans task correspond au nombre de threads. Vous pouvez utiliser ls combiné avec wc pour effectuer le comptage automatiquement.

Outre l'approche avec /proc, la commande elle-même ps peut renvoyer des informations au niveau du threadUtiliser l'option -H vous passez en « mode multithread », et avec -p Vous filtrez par PID spécifique. Si vous ajoutez -h Vous évitez les promontoires, ce qui facilite la canalisation du courant vers wc et obtenir le nombre de lignes, c'est-à-dire le nombre de LWP répertoriés pour ce processus.

Dans toutes ces méthodes, si vous les appliquez au même PID, le nombre de fils doit correspondre: le champ Threads de status, le nombre de sous-répertoires dans task et les lignes de départ de ps En mode multithread, ils devraient donner le même résultat, à de légères variations près si le processus crée ou détruit des threads à ce moment précis.

Filtrage et recherche de processus avec pgrep et grep

Lorsqu'il y a des centaines, voire des milliers de processus en cours d'exécution sur la machine, faire défiler la liste pour trouver celui qui vous intéresse est une perte de temps. C'est là que cet outil s'avère pratique. pgrep, qui recherche les processus par nom ou par modèle et renvoie directement les PID correspondants.

Avec une simple pgrep apache Vous verrez à l'écran les identifiants de tous les processus dont le nom contient ce texte. Et si vous souhaitez affiner votre recherche, vous pouvez Combiner pgrep avec des filtres utilisateurPar exemple, avec l'option -u limiter la recherche aux processus d'un compte spécifique.

Une autre tactique couramment utilisée consiste à s'appuyer sur grep filtrer la sortie de psUne commande typique pourrait être ps aux | grep apache, qui vous affichera uniquement les lignes de processus contenant le mot « apache », ainsi que leurs PID, leurs ressources et leurs commandes complètes.

N'oubliez pas que ce type de tuyauterie ajoute des processus supplémentaires (comme celui-ci). grep ou wc) à la liste, donc lorsque vous faites des choses comme ps r | wc -l Le compteur est incrémenté par la ligne d'en-tête et par les processus faisant partie du pipeline. Il est important d'interpréter correctement ces résultats afin d'éviter toute surprise concernant le nombre total de tâches.

En général, la maîtrise de ps + grep, pgrep et des options de filtrage vous permet de vous concentrer sur ce qui vous intéresse sans être submergé par les processus système que, la plupart du temps, vous pouvez ignorer lors d'une première analyse.

Contrôle et achèvement des processus

Lister et surveiller les processus est utile, mais souvent, il est nécessaire de mettre fin aux tâches problématiques ou de suivre leur état afin de libérer des ressources ou de rétablir la stabilité du système. Linux propose plusieurs outils simples pour cela.

Le plus connu est kill, qui envoie des signaux aux processus identifiés par leur PIDSi vous ne spécifiez pas de signal, un signal SIGTERM est envoyé, demandant au processus de se terminer correctement. S'il refuse, vous pouvez utiliser le signal SIGKILL (option). -9), ce qui force le processus à s'arrêter immédiatement sans donner la possibilité de libérer des ressources.

Lorsque vous ne souhaitez pas collecter les PID un par un, vous avez pkill y killall, qui opèrent sous le nom. avec pkill firefox Vous allez interrompre tous les processus dont le nom correspond à « firefox » pour votre utilisateur, tandis que killall Il a tendance à être plus agressif et peut affecter toutes les instances du programme sur le système, y compris celles d'autres utilisateurs, en fonction des autorisations.

Il est également très utile de comprendre comment ils fonctionnent. fg y bg jouer avec les processus de premier plan et d'arrière-planLorsqu'on suspend une tâche avec Ctrl+Z puis qu'on utilise bgVous l'envoyez en arrière-plan pour qu'il continue de fonctionner pendant que vous récupérez le terminal. Si vous avez ensuite besoin d'interagir à nouveau avec lui, fg la remet sur le devant de la scène.

Enfin, si vous souhaitez exécuter une tâche qui continue de fonctionner même après votre déconnexion, vous pouvez combiner nohup avec envoi en arrière-plan, par exemple nohup script.sh &Ainsi, le processus ne sera pas interrompu même si vous fermez le terminal ou si la connexion est perdue. SSHC'est très utile pour les tâches de longue durée. Si vous préférez la planifier, consultez comment planifier les tâches avec cron et at.

Définir les priorités avec nice et renice

Dans les systèmes multi-utilisateurs ou les systèmes comportant de nombreuses tâches simultanées, il ne suffit pas de savoir combien de processus ou de LWP il y a ; il est également important de savoir combien de processus ou de LWP il y a. décider quels processus sont prioritaires en termes d'utilisation du processeurC'est là que les commandes entrent en jeu. nice y renice.

Lorsque vous entamez un processus avec nice -n valor comando Vous définissez sa priorité relative. La plage typique s'étend de -20 (priorité maximale) à 19 (priorité minimale), 0 étant la valeur par défaut. Plus la valeur « nice » est élevée, plus le processus sera conciliant et cédera du temps CPU à d'autres processus en cas de concurrence pour les ressources.

Par exemple, si vous avez un script gourmand en ressources qui n'est pas urgent mais que vous souhaitez exécuter en arrière-plan sans perturber le fonctionnement d'autres applications, vous pouvez le lancer avec nice -n 10 ./script.shCela lui attribue une faible priorité afin qu'il ne monopolise pas le processeur pendant que d'autres processus interactifs sont en cours d'exécution.

Si, au lieu de modifier la priorité au démarrage, vous avez besoin de modifier la priorité d'un processus déjà en cours, tu utilises reniceAvec quelque chose comme renice -n 5 -p PID Vous modifiez la valeur nice du processus associé à ce PID, en l'adaptant aux besoins actuels (en augmentant ou en diminuant sa priorité).

Une gestion appropriée des priorités avec nice et renice permet d'éviter qu'un seul processus ou ensemble de threads ne surcharge la réactivité du système, en particulier sur les serveurs partagés ou les environnements de production avec de nombreuses charges simultanées.

Outils avancés pour le débogage et l'analyse des processus

Lorsqu'un processus ou l'un de ses LWP se comporte étrangement, plante ou semble bloquer le système, il est souvent nécessaire de recourir à des outils de diagnostic plus avancés. L'un des plus puissants est stracece qui vous permet de surveiller en temps réel les appels système effectués par un processus. Pour les erreurs de noyau plus profondes, il existe un guide sur utiliser crash et kdump.

Avec une commande comme strace -p PID Vous pouvez s'impliquer dans un processus déjà en cours et observez les appels système qu'il effectue (lecture et écriture de fichiers, opérations réseau, signaux, etc.). Ceci est particulièrement utile pour déterminer pourquoi un processus est en attente : il est peut-être bloqué en tentant d'ouvrir un fichier inexistant, en attente d'une connexion réseau ou en raison d'autorisations insuffisantes.

Un autre outil de diagnostic classique est lsof (Liste des fichiers ouverts)Cet outil affiche les fichiers ouverts par chaque processus, y compris les fichiers disque, les sockets réseau, les périphériques, etc. Il est très utile pour identifier le processus qui utilise un port spécifique, le service qui verrouille un fichier ou les tâches qui consultent un journal particulier.

Complémentaire à lsof, fuser Il vous indique quels processus utilisent un fichier ou un port. Concrètement, par exemple, avec une commande sur un port TCP, vous pouvez rapidement identifier quel démon écoute sur ce numéro et agir en conséquence, soit en le reconfigurant, soit en l'arrêtant.

Pour aller plus loin dans l'analyse des performances, vous avez pidstatqui offre des statistiques détaillées de CPU, de mémoire et d'E/S par processus, et avec watchqui vous permet d'exécuter périodiquement des commandes telles que ps -e o netstat observer à l'écran comment les processus ou les connexions évoluent au fil du temps.

Gestion des services et état général du système

De nombreux processus importants sous Linux sont en réalité services ou démons qui s'exécutent en arrière-plan, tels que les serveurs web, bases de données ou des planificateurs de tâches. Dans les systèmes modernes utilisant systemd, l'outil central de gestion de ces services est systemctl.

Avec systemctl start nombre_servicio Vous pouvez lancer un service, tandis que systemctl stop, restart y status Elles vous permettent de l'arrêter, de le redémarrer ou de consulter son état actuel. Vous pouvez également activer ou désactiver son démarrage automatique au démarrage du système, ce qui influe directement sur les processus affichés dans la liste après un redémarrage.

Dans les distributions ou configurations plus anciennes qui utilisent encore SysVinit, il est courant de trouver la commande service pour la gestion des services. Bien qu'il ait été remplacé dans de nombreux cas par systemd, il reste utile comme couche de compatibilité pour démarrer, arrêter ou redémarrer des démons spécifiques.

Au-delà des services, cela vaut la peine d'avoir une vue d'ensemble de l'état du système. La commande uptime Il indique la durée de fonctionnement de la machine, le nombre d'utilisateurs connectés et la charge moyenne récente, permettant ainsi de savoir rapidement si le système est stable ou surchargé.

Pour une analyse de performance plus détaillée, vmstat Il fournit des statistiques sur le processeur, la mémoire, les processus et l'espace d'échange., pendant que iostat Il se concentre sur les entrées/sorties disque, en affichant les lectures, les écritures et les temps de réponse des périphériques. stockageCes outils sont précieux pour déterminer si les problèmes proviennent du processeur, de la mémoire vive, du disque dur ou d'une combinaison de ces éléments.

En combinant tous les éléments ci-dessus (liste des processus et des LWP avec ps et /proc, surveillance en temps réel avec top, htop ou atop, filtrage avec pgrep, contrôle avec kill et réglage avec nice, ainsi que des utilitaires de diagnostic tels que strace et lsof), il est possible de comprendre et de contrôler très précisément ce qui se passe sur un système Linux à tout moment, d'identifier les processus et les threads problématiques et de maintenir les performances sous contrôle même dans des environnements exigeants.