Tout programme en cours d'exécution sur Linux est un processus identifié par un PID. Cette page couvre la liste, la surveillance, la terminaison via signaux UNIX, et la gestion des plans d'exécution (avant-plan, arrière-plan, détaché).
Lister et surveiller
Snapshot avec ps, monitoring en temps réel avec top et htop, vue en arbre avec pstree.
ps
Lister les processus à un instant T
ps donne une photo des processus en cours. Sa syntaxe est un peu particulière car elle accepte trois conventions historiques : BSD (sans tiret), UNIX (avec tiret), et GNU (avec double tiret). Les deux invocations les plus courantes sont ps aux (BSD) et ps -ef (UNIX).
Combinaisons usuelles
ps
Vos processus dans le terminal courant.
ps aux
Tous les processus du système, format BSD avec %CPU et %MEM.
ps -ef
Tous les processus, format UNIX avec PPID (parent).
ps -u nom
Processus d'un utilisateur précis.
ps --forest
Vue en arbre (parent → enfants).
$ ps aux | grep '[n]ginx'
Trouve tous les processus nginx en cours.
$ ps aux --sort=-%mem --no-headers | head -n 10
Top 10 des processus consommant le plus de mémoire.
Moniteur de processus interactif (intégré à tout système)
top affiche en continu les processus triés par consommation, avec rafraîchissement toutes les 3 secondes par défaut. Indispensable pour comprendre rapidement ce qui consomme.
Raccourcis dans top
P
Trier par consommation CPU (par défaut).
M
Trier par consommation mémoire.
k
Tuer un processus (demande le PID puis le signal).
r
Renicer (changer la priorité).
1
Affiche le détail par cœur CPU.
q
Quitter.
Options de lancement
-d N
Délai de rafraîchissement en secondes.
-n N
S'arrête après N rafraîchissements.
-p PID
Surveille uniquement les PID donnés.
$ top -o %MEM
Trie par consommation mémoire au lieu du CPU. Une fois lancé, M et P basculent entre les deux tris ; q pour quitter.
$ top -b -n 1 | head -15
Mode non interactif (-b), une seule itération : pratique pour capturer l'état de la machine dans un script ou un rapport.
htop propose une interface couleur, un défilement à la souris, des barres de charge par CPU, et des touches de fonction (F1–F10) pour les actions courantes.
Installation :htop n'est pas systématiquement présent. sudo apt install htop sur Debian/Ubuntu, sudo dnf install htop sur Fedora.
Touches de fonction
F2
Configuration (couleurs, colonnes).
F3
Recherche.
F4
Filtre.
F5
Vue arborescente.
F6
Critère de tri.
F9
Envoyer un signal au processus sélectionné.
F10
Quitter.
$ htop -u alex
N'affiche que les processus de l'utilisateur alex. F10 ou q pour quitter.
Retrouver un processus gourmand :
F6 puis sélectionner PERCENT_CPU ou PERCENT_MEM selon ce qu'on cherche : la liste se trie par cette colonne et les coupables remontent en tête.
F4 pour filtrer si on a déjà un bout de nom (ex. taper chrome n'affiche que les processus qui matchent).
Naviguer aux flèches pour sélectionner la ligne.
F9 pour envoyer un signal au processus choisi : SIGTERM par défaut (laisse le processus se nettoyer), SIGKILL en dernier recours s'il ne réagit pas.
Vue arborescente (F5) :
bascule en mode tree, indispensable pour comprendre la chaîne de processus enfants — par exemple un terminal qui a lancé npm run qui a lancé Webpack qui a lancé esbuild. F5 à nouveau pour revenir à la vue plate.
Voir les processus en arbre et retrouver un PID par son nom
pstree affiche les processus sous forme d'arbre, du plus ancien ancêtre (systemd) jusqu'aux commandes en cours : on voit d'un coup d'œil quel service a lancé quel programme. pidof renvoie simplement le ou les PID d'un programme à partir de son nom.
Options principales
pstree -p
Affiche le PID de chaque processus.
pstree -a
Affiche les arguments des commandes.
pstree UTILISATEUR
Ne montre que les processus d'un utilisateur.
pidof NOM
PID de toutes les instances d'un programme, séparés par des espaces.
$ pstree -p $(pidof -s sshd)
Montre l'arbre sous le démon SSH : chaque connexion ouverte, son shell et les commandes lancées. -s ne renvoie qu'un seul PID.
$ pidof nginx
1835 1834 1833
Un PID par processus nginx : le processus principal et ses workers.
Sous Linux, on n'arrête pas vraiment un processus : on lui envoie un signal qu'il intercepte (ou pas) pour décider quoi faire.
kill
Envoyer un signal à un processus
Le nom est trompeur : kill n'est pas réservé à terminer. Elle envoie n'importe quel signal POSIX à un processus identifié par son PID. Sans option, le signal envoyé est SIGTERM (terminaison polie).
Signaux les plus utiles
-15 / -TERM
Demande poliment de s'arrêter (le processus peut nettoyer avant). Comportement par défaut.
-9 / -KILL
Force la terminaison immédiate. Le processus ne peut pas l'intercepter. À utiliser en dernier recours.
-1 / -HUP
« Hangup ». Souvent utilisé pour demander à un démon de relire sa configuration.
-2 / -INT
Identique à Ctrl+C.
-STOP
Met en pause le processus.
-CONT
Reprend un processus mis en pause.
$ kill 1234
SIGTERM à PID 1234. Le processus reçoit la demande et peut faire son ménage avant de quitter.
$ kill -9 1234
Force la terminaison. Aucun nettoyage possible, le noyau coupe le processus.
# kill -HUP 1234
Envoie SIGHUP au PID choisi. Pour nginx, cibler uniquement le processus maître après vérification du PID ; systemctl reload nginx utilise la procédure définie par le service. Tous les programmes n'interprètent pas SIGHUP comme un rechargement.
$ kill -l
Liste tous les signaux disponibles avec leur numéro.
Bonne pratique :
toujours essayer kill (TERM) d'abord, attendre quelques secondes, et n'utiliser -9 que si le processus reste bloqué.
Tuer ou chercher des processus par leur nom (sans connaître le PID)
Trois outils pour traiter les processus par nom plutôt que par PID. killall match exactement le nom du programme, pkill envoie un signal aux processus correspondant à un pattern, pgrep fait juste la recherche sans tuer (toujours utile avant un pkill).
Options communes à pgrep et pkill
-f
Match sur la ligne de commande complète, pas seulement le nom du binaire.
-u USER
Limite aux processus de cet utilisateur.
-n / -o
Le plus récent (newest) ou le plus ancien (oldest) des matches.
-l
(pgrep) Affiche aussi le nom du processus.
-a
(pgrep) Affiche la ligne de commande complète.
-SIGNAL
(pkill) Signal à envoyer (défaut TERM) : -HUP, -9, etc.
$ pgrep -af nginx
1234 nginx: master process /usr/sbin/nginx
1235 nginx: worker process
Liste les PID + cmdline complète. Réflexe avant tout pkill : on vérifie qu'on cible bien ce qu'on veut.
$ pkill -HUP -F /run/nginx.pid
Envoie SIGHUP au PID lu dans le fichier du processus maître nginx. Vérifier le chemin configuré par la directive pid ; /run/nginx.pid est un exemple. Éviter pkill -HUP nginx qui viserait aussi les workers.
$ pkill -f "python.*buggy_script.py"
-f applique une expression régulière à toute la ligne de commande. Vérifier les cibles avec pgrep -af avant de signaler : un motif large peut aussi sélectionner d'autres interpréteurs ou commandes.
$ pkill -u alice -9
Tue tous les processus d'alice avec SIGKILL. Utile pour kicker une session bloquée. -u root est dangereux et exige beaucoup de prudence.
$ killall firefox
Tue tous les processus exactement nommés firefox. Plus strict que pkill : pas de pattern, juste le nom exact.
Différence subtile :killall foo match le nom de programme strict. pkill foo match si foo apparaît dans le nom. pkill -f foo match dans la ligne de commande complète. Du plus strict au plus permissif.
Avant-plan, arrière-plan, détaché du terminal, durée limitée — comment piloter ce qui s'exécute après le lancement.
jobs · bg · fg
Gérer les tâches du shell
Quand vous lancez une commande longue, vous pouvez la suspendre (Ctrl+Z), la reprendre en arrière-plan (bg) ou la ramener en avant-plan (fg).
$ sleep 1000
Dans un shell interactif avec contrôle des tâches, lancer sleep puis appuyer sur Ctrl+Z pour le suspendre. Exécuter ensuite les étapes suivantes une par une. Le numéro de tâche peut différer de 1.
$ bg %1
[1]+ sleep 1000 &
Reprend la tâche 1 en arrière-plan après sa suspension avec Ctrl+Z.
$ jobs
[1]+ Running sleep 1000 &
Vérifie les tâches du shell courant.
$ fg %1
Ramène la tâche 1 au premier plan ; Ctrl+C permet ensuite de l'arrêter.
Un & à la fin d'une ligne lance la commande en arrière-plan : le shell rend la main aussitôt et affiche le numéro de tâche et le PID. La commande reste liée au terminal.
$ long_traitement.sh &
[1] 24531
Le shell affiche le numéro de job ([1]) et le PID (24531) puis vous rend la main.
$! contient le PID de la dernière commande lancée en arrière-plan, et wait attend sa fin pour récupérer son code de sortie : la base pour lancer plusieurs tâches en parallèle dans un script.
Détacher un processus du terminal (survit à la déconnexion)
nohup démarre une commande en lui faisant ignorer SIGHUP. Selon le terminal, le shell et sa configuration, une déconnexion peut provoquer ce signal. nohup ne protège pas d'autres signaux ni d'une politique systemd qui termine les processus de la session ; pour un serveur durable, utiliser un service systemd.
$ nohup ./serveur.sh > serveur.log 2>&1 &
Lance en arrière-plan avec les sorties dans serveur.log et SIGHUP ignoré. Cela ne garantit pas la survie à une fermeture de session gérée par un autre mécanisme ; préférer systemd pour un service permanent.
Alternative moderne :
pour des sessions persistantes avec accès à la sortie, tmux ou screen sont bien plus pratiques.
La niceness Linux va de -20 à 19 ; elle influence le partage du CPU pour les politiques ordinaires. nice -n N ajoute N à la valeur héritée, alors que renice N fixe une valeur absolue avec util-linux. Diminuer la niceness exige les droits adaptés (root, CAP_SYS_NICE ou une limite RLIMIT_NICE suffisante). Cela ne réserve ni CPU ni débit disque.
Syntaxe
nice -n N commande args # ajoute N a la niceness heritee
renice N -p PID # fixe la niceness sous Linux/util-linux
renice N -u USER # processus d'un utilisateur
renice N -g PGID # groupe de processus (pas groupe Unix)
$ nice -n 19 tar czf backup.tar.gz /home &
Ajoute 19 à la niceness héritée, avec la borne maximale Linux à 19. Si la niceness initiale vaut 0, le résultat est 19 ; une valeur initiale négative peut donner un autre résultat. Cela influence le partage du CPU mais ne fixe pas une limite de débit I/O.
$ renice 10 -p $(pgrep -f long-job)
Adoucit un processus déjà en cours après s'être rendu compte qu'il bouffait le CPU. Combo classique avec pgrep pour trouver son PID.
# renice -10 -p $(pgrep -fn audio)
Augmente la priorité (valeur négative — root requis) du processus audio le plus récent. Pour les workloads temps-réel mou (audio, vidéo).
Pour l'I/O :
voir ionice (paquet util-linux) : ionice -c 3 cmd met l'I/O en classe idle (le processus ne fait des I/O que quand personne d'autre n'en veut). Souvent plus efficace que nice pour des backups ou des indexations qui saturent surtout le disque.
Régler la priorité d'accès au disque d'un processus
nice règle la part de processeur ; ionice règle la part du disque. Une sauvegarde ou une indexation en classe idle n'accède au disque que lorsque personne d'autre n'en a besoin. Son effet dépend de l'ordonnanceur d'entrées-sorties du disque : il est net avec BFQ et peut être nul avec d'autres.
Options principales
-c 3
Classe idle : accès au disque seulement quand il est libre.
-c 2 -n 0..7
Classe normale (best-effort), de 0 (prioritaire) à 7 (le moins prioritaire).
timeout lance une commande et lui envoie un signal (TERM par défaut) si elle dépasse la durée donnée. En cas de dépassement, le code de retour vaut 124, ce qui se teste facilement dans un script.
Options principales
DURÉE
Nombre suivi d'une unité : s (défaut), m, h ou d.
-s SIGNAL
Signal à envoyer au dépassement, par exemple -s INT.
-k DURÉE
Envoie KILL si la commande tourne encore ce délai après le premier signal.
--preserve-status
Renvoie le code de sortie de la commande, même en cas de dépassement.
$ timeout 10 curl -s https://exemple.fr/
Abandonne la requête si elle dure plus de 10 secondes.
$ timeout -k 5 30s ./tache.sh
echo $?
124
La tâche a dépassé 30 secondes et a reçu TERM ; si elle ne s'était pas arrêtée dans les 5 secondes suivantes, elle aurait reçu KILL.
$ if ! timeout 5 ping -c 1 serveur > /dev/null; then
echo "serveur injoignable" >&2
fi
Garde-fou classique dans un script : une vérification ne doit jamais bloquer indéfiniment.
Comprendre ce que fait un processus : lsof relie un fichier, un socket ou un descripteur au processus qui le tient ; strace montre ses appels système ; perf mesure où il passe son temps CPU.
lsof
Lister les fichiers (et sockets) ouverts
lsof (list open files) part du principe Unix « tout est fichier » : il liste ce qu'un processus a ouvert, qu'il s'agisse d'un vrai fichier, d'un socket TCP, d'un pipe ou d'un device. Indispensable pour répondre à « quel processus écoute sur ce port ? », « qui empêche le démontage de cette partition ? », « quels descripteurs ce démon a-t-il ? ».
Sélecteurs courants
-i
Filtrer sur les sockets réseau. Sans argument : tous. Avec : -i :443, -i tcp:80, -i @192.168.1.10.
-i -P -n
Combo classique : numéros de ports en clair (pas de résolution /etc/services) et IP en clair (pas de DNS reverse). Beaucoup plus rapide.
-p PID
Tous les fichiers d'un processus précis.
-u USER
Tous les fichiers ouverts par cet utilisateur. ^USER avec un caret pour exclure.
+D /chemin
Tous les fichiers ouverts dans cette arborescence. Le + (et non -) déclenche la récursion.
FICHIER
Qui a ouvert ce fichier précis : lsof /var/log/syslog.
# lsof -nP -iTCP:443 -sTCP:LISTEN
COMMAND PID USER FD TYPE NODE NAME
nginx 1234 root 6u IPv4 ... TCP *:443 (LISTEN)
nginx 1235 nginx 6u IPv4 ... TCP *:443 (LISTEN)
Qui écoute sur le port 443 ? Réponse en deux lignes. -P -n évite les résolutions inutiles. Réflexe quand un service refuse de démarrer avec « address already in use ».
# lsof +D /mnt/usb
Avant de débrancher une clé USB : qui a un fichier ouvert dessus ? Pareil quand umount renvoie « target is busy ». Une fois les coupables identifiés, on peut les fermer ou les tuer puis redémonter.
$ lsof -p $(pgrep -n nginx)
Tous les descripteurs ouverts par le processus nginx le plus récent. Utile pour savoir quels fichiers de config et de log un démon tient à un instant T.
# lsof -nP -i tcp -sTCP:ESTABLISHED
Toutes les connexions TCP établies — alternative à ss -tnp avec des informations process plus riches.
Cousins utiles :fuser (paquet psmisc) répond à la même question avec une syntaxe plus brève : fuser -mv /mnt/usb liste les processus accédant au système de fichiers. ss (page Réseau) est plus efficace spécifiquement pour les sockets.
strace affiche chaque appel système d'un programme (ouverture de fichier, lecture, connexion réseau, création de processus) avec ses arguments et son résultat. C'est l'outil pour comprendre un échec sans message clair : fichier introuvable, permission refusée, connexion qui bloque.
Options principales
-f
Suit aussi les processus enfants.
-p PID
S'attache à un processus déjà lancé.
-e trace=%file
Ne trace qu'une famille d'appels : %file, %network, %process, ou une liste comme openat,connect.
-o FICHIER
Écrit la trace dans un fichier plutôt que sur la sortie d'erreur.
-c
Affiche un résumé : nombre d'appels, erreurs et temps par appel.
Trace les accès aux fichiers puis isole les échecs : ENOENT (fichier absent) et EACCES (permission refusée) désignent souvent directement la cause.
# strace -f -tt -p 1234
S'attache au processus 1234 pour voir sur quel appel il est bloqué. Interrompre avec Ctrl+C : le processus continue normalement.
$ strace -c ls /usr/bin > /dev/null
Résumé des appels système faits par la commande, utile pour repérer un programme qui multiplie les accès disque.
Impact sur les performances :strace ralentit fortement le processus tracé. Sur un service de production chargé, limiter la trace avec -e et la garder courte.
perf s'appuie sur les compteurs matériels du processeur et les points de traçage du noyau pour mesurer l'activité d'un programme ou de tout le système. Paquet perf sur Fedora, linux-perf sur Debian, linux-tools-$(uname -r) sur Ubuntu.
Sous-commandes principales
stat CMD
Compte les événements pendant l'exécution : cycles, instructions, défauts de cache, changements de contexte.
top
Affiche en direct les fonctions qui consomment le plus de CPU.
record -g CMD
Enregistre des échantillons avec les piles d'appels dans perf.data.
report
Analyse le fichier perf.data enregistré.
list
Liste les événements disponibles sur la machine.
$ perf stat -- gzip -k gros-fichier.log
Mesure le temps et les compteurs d'une commande. Le -- sépare les options de perf de celles de la commande mesurée.
# perf top
Vue en direct des fonctions les plus coûteuses, noyau compris. Utile quand une machine chauffe sans processus évident dans top.
$ perf record -g -- ./mon-programme
perf report
Enregistre un profil avec les piles d'appels puis l'explore. Les noms de fonctions ne s'affichent que si le programme a ses symboles de débogage.
Droits :
plus la valeur de kernel.perf_event_paranoid est élevée, plus les mesures sont restreintes pour un utilisateur non privilégié, et certaines distributions la règlent haut par défaut. Lancer perf en root ou abaisser ce réglage temporairement avec sysctl.