¶ Introduction
En Linux, un processus est une instance en cours d'exécution d'un programme informatique. Plus précisément, un processus est une entité qui contient les informations nécessaires pour exécuter un programme, y compris l'état du programme, ses données, son code, ses ressources allouées et d'autres informations de gestion.
Linux/Unix est un système d'exploitation:
- Multi-tâches.
- Multi-utilisateurs.
Plusieurs processus peuvent s'exécuter en même temps
Tous les processus découlent d’un processus: Init/Systemd (processus PID 1) (ps –L -p 1)
Kernel space vs user space (systemd fait le pont)
¶ Définition
- Un processus est une instance en cours d'exécution d'un programme. Un processus est une entité active qui peut exécuter des instructions et interagir avec les ressources du système telles que les fichiers, les périphériques, les sockets, les autres processus, etc.
- Chaque processus possède un identificateur unique appelé PID (Process ID), qui est attribué par le système d'exploitation. Les processus peuvent être créés par le système d'exploitation, par d'autres processus ou par l'utilisateur.
- Les processus peuvent être exécutés en mode utilisateur ou en mode privilégié (ou "root"). Les processus exécutés en mode privilégié ont accès à toutes les ressources du système, tandis que les processus exécutés en mode utilisateur ont accès à un sous-ensemble limité de ressources.
- Les processus peuvent communiquer entre eux en utilisant des mécanismes de communication tels que les signaux, les pipes, les files d'attente de messages, les sockets, etc. Les processus peuvent également être contrôlés par d'autres processus à l'aide de commandes telles que kill, nice, renice, etc.
¶ Fonctionnement
Les processus sont au cœur du fonctionnement d'un système d'exploitation Linux. Ils représentent des programmes en cours d'exécution et sont essentiels pour la gestion des ressources du système. Voici comment fonctionnent les processus dans Linux :
- Création d'un processus : Un processus est créé lorsqu'un programme est lancé. Cela peut être un programme utilisateur que vous exécutez, un service système, ou même un processus du noyau. La création d'un processus se fait généralement à l'aide d'appels système comme fork() ou exec().
- Table des processus : Le noyau de Linux maintient une table des processus qui répertorie tous les processus en cours d'exécution. Chaque processus est identifié par un numéro unique appelé "ID de processus" (PID). La table des processus stocke des informations sur chaque processus, telles que le PID, le nom du processus, le propriétaire, l'état actuel, la priorité, la consommation de ressources, etc.
- Contexte du processus : Chaque processus a son propre "contexte". Cela comprend l'état du processeur, les registres de la CPU, la mémoire virtuelle, la pile, les descripteurs de fichiers et d'autres données associées à son exécution. Lorsqu'un processus est créé ou passe d'un état à un autre, son contexte est sauvegardé ou restauré.
- Planificateur de processus : Linux utilise un composant appelé "planificateur de processus" pour décider quel processus s'exécute sur le CPU à un moment donné. Le planificateur attribue des plages de temps d'exécution aux processus actifs. Il prend en compte des facteurs tels que les priorités, les quotas de temps CPU et la réactivité du système pour prendre des décisions de planification.
- Transitions d'état : Les processus passent par différents états tout au long de leur cycle de vie. Les états principaux incluent "Running", "Sleeping", "Zombie", "Stopped", etc. Ces transitions d'état sont gérées par le noyau en réponse à des événements, tels que des interruptions matérielles, des signaux, la fin de l'exécution, etc.
- Communication inter-processus : Les processus peuvent communiquer entre eux à l'aide de mécanismes tels que les tubes (pipes), les sockets, les signaux et les files d'attente de messages. Cela permet aux processus de partager des données, de coopérer et de réaliser des tâches plus complexes.
- Terminaison des processus : Lorsqu'un processus a terminé son exécution, il peut se terminer volontairement en appelant exit(), ou il peut être arrêté par un autre processus. Une fois qu'un processus a terminé, il devient un processus zombie jusqu'à ce que son parent récupère son code de sortie en utilisant wait().
- Gestion des ressources : Les processus ont accès aux ressources du système, telles que la mémoire, les fichiers, les périphériques, etc. Le noyau de Linux garantit que les ressources sont correctement gérées pour éviter les conflits et garantir que les processus s'exécutent de manière isolée.
¶ Caractéristiques d'un processus
- Les informations nécessaires à la gestion des processus sont stockées dans une structure de données que l’on appelle le contexte(ps –f / ps –l /ps -ux)
- Une table en mémoire contient la liste de tous les processus et de leurs contextes.
- Numéro du processus (PID)
- Processus parent (PPID)
- Numéro d’utilisateur (UID) et de groupe (GID)
- Durée de traitement et priorité
- Répertoire courant du processus
- Table de référence des fichiers ouverts
Plus d'information sur la commande PS : https://man7.org/linux/man-pages/man1/ps.1.html
¶ Type de processus
- Processus système : Ce sont des processus qui s'exécutent en arrière-plan et sont essentiels au bon fonctionnement du système d'exploitation. Ils sont démarrés automatiquement lorsque le système démarre et sont gérés par le noyau.
- Processus utilisateur : Ce sont des processus qui sont démarrés par un utilisateur lorsqu'il se connecte. Ils peuvent être des processus en premier plan ou en arrière-plan et sont gérés par le shell.
- Processus de démon (daemon): Ce sont des processus qui s'exécutent continuellement en arrière-plan et effectuent des tâches spécifiques. Les démons sont souvent utilisés pour des services tels que les serveurs web ou les serveurs de bases de données. Ils sont également gérés par le noyau. (ex.: Spooler)
¶ États d'un processus
Dans Linux, les processus passent par différents états tout au long de leur cycle de vie. Comprendre ces états est essentiel pour la gestion et la surveillance des processus. Voici les principaux états d'un processus dans Linux :
- Running (R) : L'état "Running" indique que le processus est en cours d'exécution sur le CPU. C'est l'état actif où le processus exécute ses instructions.
- Sleeping (S) : Les processus en état "Sleeping" sont actifs, mais ils ne s'exécutent pas sur le processeur à un instant donné. Ils sont en attente d'un événement (par exemple, une interruption matérielle, une entrée utilisateur, ou une minuterie) pour se réveiller et revenir à l'état "Running".
- Interruptible Sleep (D) : Les processus en état "Interruptible Sleep" sont similaires aux processus "Sleeping", mais ils peuvent être réveillés par des interruptions matérielles. Souvent, ces processus attendent des opérations d'entrée-sortie sur des périphériques (comme un disque dur), et ils peuvent être mis en veille lorsqu'ils attendent que ces opérations se terminent.
- Uninterruptible Sleep (D) : Les processus en état "Uninterruptible Sleep" sont similaires aux processus "Interruptible Sleep", mais ils ne peuvent pas être interrompus par des interruptions matérielles. Ils sont généralement en attente d'opérations d'entrée-sortie bloquantes qui ne peuvent pas être annulées. Cet état est moins courant que l'état "Interruptible Sleep".
- Stopped (T) : Les processus en état "Stopped" ont été arrêtés par l'utilisateur ou par un autre processus à l'aide de signaux, comme SIGSTOP ou SIGTSTP. Ils ne sont ni actifs ni en attente, et ils ne consomment pas de ressources du CPU.
- Zombie (Z) : Les processus en état "Zombie" sont des processus qui ont terminé leur exécution, mais dont la structure de processus n'a pas encore été supprimée de la table des processus. Ils sont généralement en attente que leur parent récupère leur code de sortie (status), après quoi ils seront complètement supprimés.
- Paging (P) : L'état "Paging" n'est pas très courant et n'est pas toujours affiché dans la sortie de la commande ps. Il indique que le processus effectue des opérations de pagination, c'est-à-dire des opérations de gestion de la mémoire virtuelle, comme le chargement ou la décharge de pages mémoire.
- Dead (X) : Les processus en état "Dead" sont terminés mais n'ont pas encore été nettoyés. Cet état est rarement observé.
- Traced (W) : Les processus en état "Traced" ont été tracés par un débogueur ou un autre outil de profilage. Cet état est également peu courant.
|
S: Interruptible sleep (waiting for an event to complete). R: Running or runnable (on run queue). D: Uninterruptible sleep (usually IO). T: Stopped, either by a job control signal or because it is being traced. Z: Defunct ("zombie") process, terminated but not reaped by its parent. <: High-priority (not nice to other users). N: Low-priority (nice to other users). L: Has pages locked into memory (for real-time and custom IO). s: Is a session leader. l: Is multi-threaded (using CLONE_THREAD, like NPTL pthreads do). +: Is in the foreground process group. |
¶ La commande PS
La commande ps (Process Status) est un utilitaire fondamental sous Linux qui permet d'afficher des informations sur les processus en cours d'exécution sur le système. Voici une explication détaillée :
¶ Fonction de base
ps fournit un instantané des processus actifs, avec des informations comme leur identifiant (PID), le terminal associé, le temps CPU consommé et la commande exécutée.
¶ Options courantes
Sans option, ps affiche uniquement les processus associés au terminal actuel. Les options les plus utilisées sont :
ps -eoups -A: affiche tous les processus du systèmeps -f: format complet (informations détaillées)ps -l: format long (encore plus d'informations)ps -u username: processus d'un utilisateur spécifiqueps aux: affiche tous les processus avec des informations détaillées (combinaison très populaire)
¶ Exemple de sortie
Pour ps aux, vous verrez des colonnes comme :
USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND
root 1 0.0 0.1 169020 9256 ? Ss mai05 0:26 /sbin/init¶ Signification des colonnes principales
USER: propriétaire du processusPID: identifiant du processus%CPU: pourcentage d'utilisation du CPU%MEM: pourcentage d'utilisation de la mémoireVSZ: taille virtuelle du processus en KoRSS: taille mémoire physique utilisée en KoTTY: terminal de contrôleSTAT: état du processus (R=running, S=sleeping, Z=zombie, etc.)START: heure de démarrageTIME: temps CPU cumuléCOMMAND: commande exécutée
¶ Filtrage et tri
Vous pouvez combiner ps avec d'autres commandes comme grep pour filtrer les résultats :
ps aux | grep firefox¶ Voici des exemples d'utilisation
Pour afficher une liste de tous les processus en cours d'exécution sur le système, utilisez simplement la commande ps sans aucun argument
ps
Par défaut, ps affiche les processus associés à l'utilisateur actuel. Pour afficher tous les processus de tous les utilisateurs, utilisez l'option -e ou --everyone :
ps –e
Pour obtenir plus d'informations sur les processus, utilisez l'option -f pour afficher une liste plus détaillée, y compris l'utilisateur, le PID, le PPID (Parent Process ID), le statut, la consommation de ressources, etc. :
ps -ef
Pour afficher uniquement les processus d'un utilisateur spécifique, utilisez l'option -u suivie du nom de l'utilisateur :
ps –u tilisateur
Pour afficher les threads associés aux processus, utilisez l'option -L. Par exemple, pour afficher les threads du processus avec le PID 12345 :
ps –L –p 12345
ps -f 1
¶ La commande JOBS
La commande jobs permet d'afficher les tâches ou processus en cours d'exécution en arrière-plan dans le shell courant.
¶ Fonction principale
jobs affiche la liste des tâches en cours d'exécution ou suspendues dans votre session shell actuelle. Contrairement à ps qui montre tous les processus du système, jobs se concentre uniquement sur les processus associés à votre shell.
¶ Contexte d'utilisation
La commande jobs est particulièrement utile dans un environnement de multitâche où vous exécutez plusieurs programmes depuis un même terminal.
¶ Statut des tâches
Une tâche peut avoir différents états :
Running: en cours d'exécutionStopped: suspendue (par exemple avec Ctrl+Z)Done: terminée
¶ Options courantes
jobs: liste toutes les tâchesjobs -l: inclut les PID des processusjobs -p: affiche uniquement les PIDjobs -s: liste seulement les tâches arrêtéesjobs -r: liste seulement les tâches en cours d'exécution
$ sleep 100 &
[1] 12345
$ nano fichier.txt
^Z
[2]+ Stopped nano fichier.txt
$ jobs
[1]- Running sleep 100 &
[2]+ Stopped nano fichier.txt¶ Commandes associées
jobs fait partie d'un ensemble de commandes de gestion des tâches :
&(à la fin d'une commande) : lance un processus en arrière-planCtrl+Z: suspend temporairement un processus en premier planbg [%num]: reprend une tâche suspendue en arrière-planfg [%num]: ramène une tâche en premier plankill %num: termine une tâche spécifique
Le numéro entre crochets [1] est l'identifiant de la tâche, qui peut être référencé avec %1 dans les commandes fg, bg ou kill.
¶ La commande FG et BG
La commande fg est utilisée pour passer un travail en arrière-plan qui s'exécute en premier plan (foreground), ce qui signifie que le travail est affiché à l'écran et peut recevoir des entrées de l'utilisateur. Pour exécuter un travail en arrière-plan en premier plan, vous devez utiliser la commande fg suivie de l'identificateur de travail (job ID) du travail en arrière-plan. Par exemple, fg %1 passera le premier travail en arrière-plan en premier plan.
fg %1La commande bg est utilisée pour reprendre un travail qui a été arrêté ou mis en attente et le faire exécuter en arrière-plan (background). Pour exécuter un travail en arrière-plan à partir d'un état arrêté ou en attente, vous devez utiliser la commande bg suivie de l'identificateur de travail (job ID) du travail en question. Par exemple, bg %1 reprendra le premier travail en attente ou arrêté et le fera exécuter en arrière-plan. Pour commencer un processus en ‘background’ on peut appeler la fonction est rajouter & (ex.: sleep 700 &)
sleep 700 &¶ Exemples
Voici un exemple de l’utilisation fg et bg. Vous pouvez démarrer un processus en arrière-plan en ajoutant un & à la fin de la commande. Par exemple, pour éditer un fichier avec Nano en arrière-plan, vous pouvez faire :
nano mon_fichier.txt &
Le processus Nano sera démarré en arrière-plan, et vous pouvez continuer à utiliser le terminal pour d'autres tâches.
Pour voir la liste des processus en cours d'exécution dans le terminal, vous pouvez utiliser la commande jobs. Elle affichera les numéros de travail (job numbers) attribués à chaque processus.
jobsVous verrez une sortie qui ressemble à ceci :
Si vous souhaitez amener un processus en arrière-plan à l'avant-plan, vous pouvez utiliser la commande fg suivie du numéro de travail (job number) du processus. Par exemple, pour amener Nano à l'avant-plan, utilisez :
fg %1¶ Gestion des processus
¶ Parent vs enfant
Dans un système Linux, les processus sont organisés selon une structure hiérarchique de type arbre généalogique. Voici une explication détaillée de cette relation parent-enfant :
¶ Concept fondamental
Chaque processus dans Linux (à l'exception du tout premier) est créé par un autre processus. Le processus qui crée est appelé processus parent, tandis que le processus nouvellement créé est appelé processus enfant.
¶ Création d'un processus enfant
Un processus parent crée un processus enfant principalement via deux appels système :
- fork() : Crée une copie presque identique du processus parent. Après un fork(), le parent et l'enfant exécutent le même code, mais avec des PID différents.
- exec() : Généralement appelé après fork(), il remplace le code du processus enfant par un nouveau programme.
¶ Caractéristiques de la relation parent-enfant
- Héritage : Le processus enfant hérite de nombreux attributs du parent :
- Variables d'environnement
- Descripteurs de fichiers ouverts
- Répertoire de travail
- Masque de création de fichiers (umask)
- Gestionnaires de signaux
- PID et PPID :
- Chaque processus a un identifiant unique (PID)
- Chaque processus connaît l'identifiant de son parent (PPID)
- Hiérarchie :
- Le processus init/systemd (PID 1) est l'ancêtre de tous les processus
- Un parent peut avoir plusieurs enfants
- Un enfant n'a qu'un seul parent
- Le parent hérite de stdIn/stdOut/stdErr
- Différence avec exec ls –l (la commande remplace le Shell)
- ps f (avec hiérarchie)
¶ Terminaison et processus orphelins
- Quand un processus se termine, le noyau envoie un signal SIGCHLD à son parent
- Le parent peut attendre la fin de ses enfants avec wait() ou waitpid()
- Si un parent se termine avant ses enfants, les enfants deviennent "orphelins" et sont adoptés par init/systemd
¶ Processus zombies
- Un processus qui s'est terminé mais dont l'entrée dans la table des processus n'a pas été supprimée (car le parent n'a pas appelé wait())
- Apparaît comme "Z" ou "defunct" dans la liste des processus
¶ Visualisation de la hiérarchie
Vous pouvez visualiser cette relation avec des commandes comme :
ps foups -ef --forest: affiche les processus en arborescencepstree: affiche un arbre des processus
Cette structure hiérarchique est fondamentale pour comprendre comment les processus sont gérés, contrôlés et surveillés dans un système Linux.
¶ Commandes clavier
- CTRL-C (arrête un processus ) (ex.: sleep 30)(kill -2)
- CTRL-Z (suspends un processus) (ex.:sleep 30) (kill –STOP)
- Pour démarrer le processus: kill –CONT
¶ La commande KILL
La fonction kill une commande shell qui est utilisée pour envoyer un signal à un processus. Les signaux sont des messages envoyés par le système d'exploitation à un processus pour l'informer de divers événements, tels qu'un arrêt d'urgence, une interruption, une fin de processus, etc.
kill –l (permet de voir tous les signaux)
Les signaux les plus importants:
Différence entre kill -9 vs kill -15 (kill -9 ne peux pas échouer!)
Pour les programmeurs, voici un bon site qui explique les différents signaux à tenir en compte dans votre code:
https://www.stackstate.com/blog/sigkill-vs-sigterm-a-developers-guide-to-process-termination/
- "kill -15 PID" : envoie le signal SIGTERM (15) au processus avec l'identifiant de processus (PID) spécifié. Ce signal demande au processus de terminer de manière propre en effectuant ses opérations de fermeture, ce qui peut permettre d'enregistrer les données ou l'état du processus avant sa fermeture.
- "kill -2 PID" : envoie le signal SIGINT (2) au processus avec l'identifiant de processus (PID) spécifié. Ce signal est généralement utilisé pour demander l'interruption d'un processus en cours d'exécution, par exemple en appuyant sur Ctrl+C dans un terminal.
- "kill -1 PID" : envoie le signal SIGHUP (1) au processus avec l'identifiant de processus (PID) spécifié. Ce signal est généralement utilisé pour demander à un processus de recharger sa configuration ou ses paramètres. (ne tue pas l’application, demande de ‘reloader sa configuration’)
- "kill -9 PID" : envoie le signal SIGKILL (9) au processus avec l'identifiant de processus (PID) spécifié. Ce signal tue immédiatement le processus, sans lui permettre de terminer de manière propre ou de libérer des ressources. C'est un signal de dernier recours qui doit être utilisé avec précaution, car il peut provoquer des pertes de données ou des problèmes de cohérence.
- Kill -15, -2 : signal gracieux
- Kill -1, -9: signal brutal (risque de perdre des données)
¶ La commande NICE
On peut gérer la priorité d'un processus en utilisant la commande nice. La commande nice permet de modifier la priorité d'un processus en ajustant son niveau de priorité de planification dans le système d'exploitation.
La priorité d'un processus est définie par une valeur appelée "niceness", qui va de -20 (la priorité la plus élevée) à 19 (la priorité la plus basse). Plus la valeur de la niceness est basse, plus la priorité du processus est élevée.
Pour augmenter la priorité d'un processus en modifiant sa niceness, vous pouvez utiliser la commande nice. Par exemple, pour exécuter un processus avec une priorité plus élevée (une niceness plus basse), vous pouvez utiliser la commande suivante :
nice- n -10 nom_du_processusIl n’est pas possible modifier la priorité d’un processus en cours (il faut utiliser la commande renice)
Il faut les droits admin (SUDO) pour exécuter la commande nice
Source: https://linuxopsys.com/topics/nice-command-in-linux-with-example
¶ La commande RENICE
La commande renice dans Linux permet de modifier la priorité d'exécution (la valeur "nice") d'un ou plusieurs processus déjà en cours d'exécution. Voici une explication détaillée :
¶ Concept de base
Dans Linux, chaque processus a une valeur de "niceness" qui détermine sa priorité d'ordonnancement. Cette valeur va de -20 (priorité la plus haute) à +19 (priorité la plus basse), avec 0 comme valeur par défaut.
- Plus la valeur est basse, plus le processus reçoit d'attention du CPU
- Plus la valeur est élevée, plus le processus est "gentil" (nice) avec les autres processus en leur cédant des ressources
¶ Syntaxe de base
renice [priorité] -p [PID]¶ Options principales
-p PID: Spécifie le PID (identifiant de processus) à modifier-u utilisateur: Modifie tous les processus appartenant à l'utilisateur spécifié-g groupe: Modifie tous les processus appartenant au groupe spécifié
¶ Exemples d'utilisation
Diminuer la priorité d'un processus (le rendre plus "gentil") : Ce processus (PID 1234) devient moins prioritaire
renice +10 -p 1234Augmenter la priorité d'un processus (nécessite généralement des privilèges root)
sudo renice -5 -p 1234Modifier la priorité de tous les processus d'un utilisateur
renice +5 -u utilisateurModifier plusieurs processus à la fois
renice +3 -p 1234 -p 5678 -p 9012¶ Restrictions importantes
- Les utilisateurs normaux peuvent seulement :
- Diminuer la priorité de leurs propres processus (augmenter la valeur nice)
- Ne peuvent pas l'augmenter une fois diminuée
- Seul l'utilisateur root (ou via sudo) peut :
- Augmenter la priorité des processus (valeurs négatives)
- Modifier la priorité des processus d'autres utilisateurs
- Réduire la valeur nice d'un processus déjà modifié
¶ Utilisation pratique
La commande renice est particulièrement utile pour équilibrer les ressources système :
- Réduire l'impact des tâches intensives en CPU mais non critiques (compilations, encodages vidéo)
- Donner plus de ressources aux applications interactives pour améliorer la réactivité du système
renice est souvent utilisée en conjonction avec des commandes comme top ou ps qui permettent d'identifier les PID et valeurs nice actuelles des processus.
¶ Exemple d'exercice
Voici une solution complète pour l'exercice sur la gestion des processus Linux :
- Lancer un processus en arrière-plan: Cela lance l'éditeur nano en arrière-plan et affiche son numéro de job et PID.
nano &- Lister des processus en arrière-plan: Cette commande affiche tous les jobs lancés depuis le terminal actuel.
jobs- Suspendre le processus courant: Le processus sera mis en pause et vous recevrez un message "[x]+ Stopped".
# Lancer un processus en premier plan
nano pablo
# Puis appuyer sur Ctrl+Z pour le suspendre- Basculer un processus en avant-plan: Ramène le job n°1 au premier plan.
fg %1- Basculer un processus en arrière-plan: Reprend l'exécution du job n°1 en arrière-plan.
bg %1- Attendre la fin d'un processus en arrière-plan: Le shell attendra que le job n°1 se termine avant de rendre la main.
wait %1- Affichage des processus en cours: Affiche tous les processus du système avec des informations détaillées.
ps aux- Arrêt d'un processus: Envoie le signal SIGTERM au processus spécifié.
kill %1
# ou avec le PID
kill 1234- Envoi d'un signal à un processus: Envoie le signal SIGUSR1 (10) au processus avec le PID 1234.
kill -SIGUSR1 1234
# ou par numéro de signal
kill -10 1234- Changer la priorité d'un processus: Plus la valeur est élevée, plus la priorité est basse (-20 à +19).
# Lancer avec une priorité spécifique
nice -n 10 find / -name "*.txt"
# Modifier la priorité d'un processus existant
renice +5 -p 1234¶ La commande top
La commande top est un outil de surveillance système en temps réel dans Linux. Elle affiche une vue dynamique des processus en cours d'exécution sur votre système. Voici une explication détaillée :
¶ Fonctionnalités principales de top
- Affichage en temps réel : Actualise périodiquement les informations (par défaut toutes les 3 secondes).
- En-tête système : Les premières lignes montrent :
- L'heure actuelle, le temps d'activité du système
- Le nombre d'utilisateurs connectés
- La charge moyenne du système (load average)
- Statistiques CPU (pourcentage d'utilisation par type : utilisateur, système, nice, idle, etc.)
- Utilisation de la mémoire (totale, utilisée, libre, buffers/cache)
- Utilisation du swap
- Liste des processus : Pour chaque processus, affiche :
- PID (identifiant du processus)
- USER (propriétaire du processus)
- PR (priorité)
- NI (valeur nice)
- VIRT (mémoire virtuelle utilisée)
- RES (mémoire physique utilisée)
- SHR (mémoire partagée)
- S (état du processus)
- %CPU (pourcentage d'utilisation du CPU)
- %MEM (pourcentage d'utilisation de la mémoire)
- TIME+ (temps CPU utilisé)
- COMMAND (nom de la commande)
¶ Commandes interactives
Pendant l'exécution de top, vous pouvez utiliser ces touches :
q: Quitterhou?: Afficher l'aidek: Tuer un processus (demande le PID)r: Changer la priorité d'un processus (renice)f: Gérer les colonnes affichéeso: Changer l'ordre de triM: Trier par utilisation mémoireP: Trier par utilisation CPU (défaut)1: Afficher tous les cœurs CPU individuellementc: Afficher le chemin complet des commandesV: Affichage en arborescence (parent/enfant)
¶ Options de lancement
Quelques options utiles :
top -d 5: Actualiser toutes les 5 secondestop -u username: Afficher uniquement les processus d'un utilisateur spécifiquetop -p 1234: Surveiller uniquement le processus avec PID 1234top -b: Mode batch (non interactif, utile pour rediriger la sortie)
top est un outil essentiel pour diagnostiquer les problèmes de performance et comprendre ce qui consomme les ressources de votre système Linux.
¶ La commande htop
La commande htop est un utilitaire interactif de surveillance des processus pour les systèmes Linux, plus évolué et convivial que la commande top classique. Voici une explication détaillée :
¶ Présentation générale
htop affiche une interface colorée en temps réel qui permet de visualiser et gérer les processus système. Contrairement à top, il offre une navigation plus intuitive et des fonctionnalités supplémentaires accessibles directement via le clavier.
¶ Principales caractéristiques
- Affichage en couleur : Facilite la lecture et la compréhension des informations
- Navigation : Défilement vertical et horizontal avec les touches fléchées
- Sélection des processus : Possibilité de sélectionner plusieurs processus à la fois
- Tri interactif : Classement des processus selon différents critères (CPU, mémoire, PID, etc.)
- Arborescence : Visualisation de la hiérarchie des processus (relation parent-enfant)
- Recherche : Fonction de recherche pour trouver rapidement un processus spécifique
¶ Structure de l'interface
L'écran de htop est divisé en deux sections principales :
- Section supérieure : Affiche des graphiques et statistiques sur :
- Utilisation des CPU (par cœur)
- Utilisation de la mémoire et du swap
- Charge système (load average)
- Uptime (temps écoulé depuis le démarrage)
- Section inférieure : Liste des processus avec leurs informations :
- PID (identifiant du processus)
- USER (propriétaire)
- PRI/NI (priorité/nice)
- VIRT/RES/SHR (utilisation mémoire)
- S (état du processus)
- CPU% (pourcentage d'utilisation CPU)
- MEM% (pourcentage d'utilisation mémoire)
- TIME+ (temps CPU cumulé)
- Command (ligne de commande)
¶ Fonctionnalités principales
- F1-F10 : Accès aux diverses fonctions (aide, configuration, recherche, etc.)
- F9 : Menu pour envoyer des signaux (kill, terminate, etc.)
- F5 : Affichage en arborescence
- F6 : Tri par colonne
- Space : Sélectionner un processus (pour actions groupées)
- u : Filtrer par utilisateur
- h : Afficher l'aide
¶ Avantages par rapport à top
- Interface plus intuitive
- Navigation plus facile
- Visualisation des processus en arborescence
- Sélection et manipulation simplifiées des processus
- Configuration plus accessible
- Support de la souris