# Processus

# Les processus sous Unix

Unix est un système multi-tâches, c'est-à-dire qu'il peut exécuter plusieurs programmes à la fois. Un processus est une instance d'un programme en train de s'exécuter, une tâche. Le shell crée un nouveau processus pour exécuter chaque commande.

## Mettre un processus en tâche de fond

Si on lance une commande qui prend beaucoup de temps (comme un calcul, ou une nouvelle fenêtre), on peut l'interrompre par `Control-C`. Ceci interrompt (définitivement) la commande. On peut aussi exécuter une commande en tâche de fond. Le shell rend alors la main avant la fin de la commande. Pour le faire, on ajoute un `&` à la fin de la commande ; par exemple :

    chaland ~ $ cc -o grosprogramme grosfichier.c &

    chaland ~ $ xdvi monrapport.dvi &

Dans le premier exemple, on lance le compilateur `cc` en parallèle avec le shell; dans le second exemple, on met le `dvi` en tâche de fond, ce qui évite d'avoir à le relancer à chaque modification.

On reprend la main immédiatement, sans attendre la fin de l'exécution de la commande. On peut donc taper d'autres commandes dans le même terminal, pendant que la précédente s'exécute.

### background et foreground

Comme on vient de le voir, si vous avez pensé à terminer votre ligne de commande par une esperluette, le programme que vous avez lancé tourne en arrière-plan (background, abrégé en `bg`).

Si vous avez omis l'esperluette, le programme prend la précédence sur le shell. On dit qu'il tourne au premier plan (foreground, abrégé en `fg`). Les lignes tapées au clavier sont mémorisées mais ne seront pas exécutées par le shell avant que le programme en cours d'exécution n'ait fini son calcul. Vous pouvez malgré tout faire passer ce programme en tâche de fond, grâce à la manipulation suivante :

    chaland ~ $ xdvi rapport.dvi
    ^Z
    zsh: suspended xdvi rapport.dvi
    chaland ~ $ bg
    [1] + continued xdvi rapport.dvi
    chaland ~ $

`^Z` est un signal intercepté par le shell, qui suspend l'exécution du programme sans détruire le processus correspondant. Les calculs déjà effectués par ce programme ne sont pas perdus. Dans l'exemple précédent, si on demande à un `xdvi` suspendu de changer de page (`SPC`), il ne le fera pas, mais il se souviendra de le faire dès qu'il aura à nouveau accès aux ressources de l'ordinateur. À partir de l'état suspendu, on peut faire passer un programme :

- au premier plan, en tapant `fg` ;
- en arrière-plan, en tapant `bg`.

Son exécution reprend alors là où on l'avait laissée.

Quand il n'y a qu'un seul programme en arrière-plan dans le terminal courant, on peut le faire passer au premier plan en tapant `fg`. Cela permet en particulier d'interrompre son exécution grâce à `^C`, que la plupart des programmes comprennent.`^C` n'affecte que l'éventuel unique programme qui tourne au premier plan dans le terminal où il est tapé. Quand il y en a plusieurs, c'est un peu plus compliqué, mais c'est bien sûr possible.

Vous pouvez pratiquer `^C`, `^Z`, `fg`, `bg` de façon visuelle et didactique en lançant la commande

    xdaliclock -seconds -geometry 500x100+0+0 -font BUILTIN

et en observant attentivement les secondes (pensez à en laisser quelques-unes s'écouler). Vous remarquerez que ce programme finit la transition en cours avant de se remettre à l'heure.

Résumé :

- Le programme tourne au premier plan :
  - `^Z` le suspend ;
  - `^C` l'interrompt.
- Le programme est suspendu :
  - `fg` le passe au premier plan ;
  - `bg` le passe en arrière-plan.
- Le programme tourne en arrière-plan :
  - si c'est le seul dans ce cas, `fg` le passe au premier plan ;
  - sinon, c'est plus compliqué.
- Le programme ne tourne pas :
  - il n'y a rien à faire...

## Voir les processus

La commande `ps` montre où en sont les tâches de fond :

    chaland ~ $ ps
     PID TT STAT TIME COMMAND
     4450 p9 S 0:00 /usr/local/bin/lcsh
     4782 p9 S 0:02 cc -o grosprogramme grosfichier.c
     4841 p9 R 0:00 ps

`ps` affiche la liste des processus que vous avez lancés :

- `PID` (process identificator) : c'est le numéro du processus.
- `TT` : indique le terminal dans lequel a été lancé le processus. Un point d'interrogation signifie que le processus n'est attaché à aucun terminal (par exemple les démons).
- `STAT` : indique l'état du processus :
  - `R` : actif ( running)
  - `S` : non activé depuis moins de 20 secondes (sleeping)
  - `I` : non activé depuis plus de 20 secondes (idle)
  - `T` : arrêté (suspendu)
  - `Z` : zombie
- `TIME` : indique le temps machine utilisé par le programme (et non pas le temps depuis lequel le processus a été lancé !).

La commande `ps` a différentes options, dont les suivantes :

- `a` (all) : donne la liste de tous les processus, y compris ceux dont vous n'êtes pas propriétaire.
- `g` (global, général...) : donne la liste de tous les processus dont vous êtes propriétaire.
- `u` (user, utilisateur) : donne davantage d'informations (nom du propriétaire, heure de lancement, pourcentage de mémoire occupée par le processus, etc.).
- `x` : affiche aussi les processus qui ne sont pas associés à un terminal.
- `w` : le tronque pas à 80 caractères (peut être utilisée plusieurs fois pour tronquer plus loin)

`ps agux` est en fait souvent utilisé pour avoir des informations sur tout les processus.

La commande `top` affiche les mêmes informations, mais de façon dynamique : elle indique en fait par ordre décroissant le temps machine des processus, les plus gourmands en premier. C'est rigolo quand la machine rame, et c'est très instructif sur les processus gourmands en ressources...

## Tuer les procesus

Les programmes ont tous une commande spécifique pour les quitter (`q`, menu où cliquer, etc). C'est seulement dans le cas où vous ne parvenez pas à les quitter correctement, pour une raison ou une autre, que vous pouvez avoir besoin de tuer le processus.

Avant toute chose, essayez de taper `^C` ou `^D`. Si cependant ça ne marche pas, utilisez la commande `kill` (plus le numéro du processus).

    chaland ~ $ ps
     PID TT STAT TIME COMMAND
     4450 p9 S 0:00 /usr/local/bin/lcsh
     4782 p9 S 0:02 cc -o grosprogramme grosfichier.c
     4841 p9 R 0:00 ps
    chaland ~ $ kill 4782
    chaland ~ $ ps
     PID TT STAT TIME COMMAND
     4450 p9 S 0:00 /usr/local/bin/lcsh
     4851 p9 R 0:00 ps

`kill -9` tue le processus à tous les coups. Vous ne pouvez tuer que les processus dont vous êtes propriétaire. Il convient de ne l'utiliser que si aucune autre méthode ne marche, car dans ce cas le programme n'a aucun moyen de faire quoi que ce soit avant de mourir.

## Contrôle des ressources

La possibilité d'exécuter plusieurs commandes à la fois (et aussi sur plusieurs machines) pose un problème immédiat de coexistence pacifique. Ce n'est pas gentil de lancer tous ses programmes de calcul lourds sur la machine d'un copain et partir en vacances le weekend : il peut arriver (et il est arrivé) qu'il ne puisse même plus se connecter. Voilà quelques outils pour vivre paisiblement :

- `nice` exécute un programme à priorité plus basse (faire `man nice`).
- `limit` commande interne du shell, permet de limiter les ressources à disposition de votre processus (très utile typiquement avec `maple` ou autres applications gourmandes en mémoire) (faire `man csh`, `man zshbuiltins`).

Dernière modification le 2002-11-23.