Pour afficher les processus (programmes en cours d'execution) utiliser les commandes ps ou pstree:

yoann@janus:~$ ps aux
USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root         1  0.0  0.0   2784  1712 ?        Ss   Apr03   0:00 /sbin/init
root         2  0.0  0.0      0     0 ?        S    Apr03   0:00 [kthreadd]
...
yoann@janus:~$

L'argument -p de pstree permet d'afficher les PIDs:

yoann@janus:~$ pstree -p
...
  └─yakuake(2217)─┬─bash(3309)───ssh(4258)
                        ├─bash(4261)───tail(4489)
                        ├─bash(4337)─┬─pstree(4626)
                        │            └─tsclient(4354)───vncviewer(4355)
                        └─{yakuake}(2242)
yoann@janus:~$

La commande pgrep permet de récupérer facilement le PID d'un processus dont on connait partiellement le nom. L'option -l permet de retourner également le nom du processus. Par défaut seul le PID est retourné:

yoann@janus:~$ pgrep -l fire
1175 firegl
2332 firefox

Le shell offre une fonctionnalité de gestion des processus désignée job control. Une tâche(job) est plus qu'un processus. Elle peut être constituée par un groupe de processus, comme cela peut être le cas dans des commandes qui s’enchaînent sur une même ligne de commande. Pour les tâches existantes, utiliser la commande jobs:

yoann@janus:~$ jobs
[1]-  Running                 sleep 40m &
[2]+  Running                 tail -f /var/log/messages &
yoann@janus:~$

Dans cet exemples deux jobs s'exécutent en arrière plan. Chaque job est identifié par un numéro. Il est possible de récupérer l'exécution du job en avant plan avec la commande fg

yoann@janus:~$ fg %2
tail -f /var/log/messages

Lorsque l'application est au premier plan, elle peut être mise en pause avec ctrl+Z. Une fois le processus fils en pause, la main est rendue au shell. Le processus apparait dans la liste des jobs existant dans l'état stoppé.

yoann@janus:~$ jobs
[2]+  Stopped                 tail -f /var/log/messages
yoann@janus:~$

Pour reprendre l'exécution du processus en arrière plan, utiliser la commande bg

yoann@janus:~$ bg %2
[2]+ tail -f /var/log/messages &
yoann@janus:~$ jobs
[2]+  Running                 tail -f /var/log/messages &
yoann@janus:~$

Les commandes bg et fg n'autorisent le contrôle que des processus fils du shell courant (jobs). De manière générale, le contrôle de l’exécution des processus s’effectue en envoyant des signaux.

Pour envoyer des signaux aux processus, on disposera entre autre des commandes kill, killall, pkill et skill.

Les signaux sont envoyés par le système ou les commandes skill et kill* pour contrôler les processus. La commande kill permet de lister les signaux disponibles:

kill -s

Ci dessous la description de quelques signaux usuels:

La commande kill avec le signal -9 permet de forcer l'arrêt d'un processus identifié par son PID.

killall a le même effet mais le processus est désigné par le nom de son exécutable. pkill agit de la même manière mais fonctionne même avec un nom partiel (utilise les expression régulières)

$ pkill firefox
$ pkill -9 tomboy
$ pkill -KILL thunderbird
$ sudo killall apache2

Dans l'exemple ci-dessous, la première commande affiche le PID du shell courant. La commande pstree permet d'afficher l'arborescence des processus. On choisit ici de contrôler l'exécution du processus 4489 ne dépendant pas du shell courant.

yoann@janus:~$ echo $$
4337
yoann@janus:~$ pstree -p
...
       └─yakuake(2217)─┬─bash(3309)───ssh(4258)
                        ├─bash(4261)───tail(4489)
                        ├─bash(4337)─┬─pstree(4666)
                        │            └─tsclient(4354)───vncviewer(4355)
                        └─{yakuake}(2242)

Les commandes ps et grep permettent d'afficher l'état du processus 4489. Ici on peut voir qu'il est en cours d'exécution, dans l'état sommeil (Sleep).

yoann@janus:~$ ps aux | grep 4489
yoann     4489  0.0  0.0   3256   648 pts/2    S    08:25   0:00 tail -f /var/log/messages

On envoie les signaux -STOP et -CONT et on vérifie l'état du processus:

yoann@janus:~$ kill -STOP 4489
yoann@janus:~$ ps aux | grep 4489
yoann     4489  0.0  0.0   3256   648 pts/2    T    08:25   0:00 tail -f /var/log/messages
yoann@janus:~$ kill -CONT 4489
yoann@janus:~$ ps aux | grep 4489
yoann     4489  0.0  0.0   3256   648 pts/2    S    08:25   0:00 tail -f /var/log/messages
yoann     4746  0.0  0.0   3336   812 pts/3    R+   10:46   0:00 grep --color=auto 4489
yoann@janus:~$

Le processus 4489 est bien arrêté après réception du signal STOP (état T affiché par ps) puis revient bien en état exécution en sommeil après réception du signal CONT (état S affiché par ps).

La commande nice permet de gérer la priorité d'exécution associée à un processus. La plage de valeur nice est comprise entre [-20,19] une valeur basse correspond à une priorité élevée.

# baisser la priorité d’exécution de la commande tail
nice -n 15 tail -f /var/log/

$ ps -l
F S   UID     PID    PPID  C PRI  NI ADDR SZ WCHAN  TTY          TIME CMD
0 S  1000    2468    2460  0  80   0 -  3583 do_wai pts/0    00:00:00 bash
0 T  1000    4715    2468  0  95  15 -  2667 do_sig pts/0    00:00:00 tail
4 R  1000    4737    2468  0  80   0 -  3515 -      pts/0    00:00:00 ps

Comme le shell est le parent de tous les processus de l’utilisateur, lorsque le shell se termine à la fermeture de la session (déconnexion), tous les processus d’arrière plan (qui sont aussi fils) sont terminés. Lorsque la session se termine, le signal SIGHUP est envoyé à tous les processus fils.

La commande nohup rend un processus insensible aux signaux INT et HUP. C’est un moyen de détacher un processus d’arrière plan du shell. La commande nohup permet de continuer l'exécution d'un processus même après déconnexion de l'utilisateur courant.

• http://www.tldp.org/LDP/GNU-Linux-Tools-Summary/html/controlling-processes.html