tuteurs.ens.fr/unix/processus.tml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE html
  PUBLIC "-//ENS/Tuteurs//DTD TML 1//EN"
  "tuteurs://DTD/tml.dtd">
<html>
<head>
<title>Processus</title>
</head>
<body>
 
<h1>Les processus sous Unix</h1>

<div class="resume">
<p>
Unix est un système <em>multi-tâches</em>, 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.
</p>
</div>

<h2><a name="fond">Mettre un processus en tâche de fond</a></h2>

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

<pre>
<span class="prompt">chaland ~ $</span> cc -o grosprogramme grosfichier.c &amp;

<span class="prompt">chaland ~ $</span> xdvi monrapport.dvi &amp;</pre>

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

<p>
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. 
</p>

<h3><em>background</em> et <em>foreground</em></h3>

<p>
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 (<em>background</em>, abrégé en <code>bg</code>).
</p>

<p>
Si vous avez omis l'esperluette, le programme prend la précédence sur le shell.
On dit qu'il tourne au premier plan (<em>foreground</em>, abrégé en
<code>fg</code>).
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 :
</p>

<pre>
<span class="prompt">chaland ~ $</span> xdvi rapport.dvi
^Z
zsh: suspended xdvi rapport.dvi
<span class="prompt">chaland ~ $</span> bg
[1] + continued xdvi rapport.dvi
<span class="prompt">chaland ~ $</span></pre>

<p>
<code>^Z</code> 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 <code>xdvi</code> suspendu de changer de page
(<code>SPC</code>), 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 :
</p>

<ul>
<li>au premier plan, en tapant <code>fg</code> ;</li>
<li>en arrière-plan, en tapant <code>bg</code>.</li>
</ul>

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

<p>
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 <code>fg</code>.
Cela permet en particulier d'interrompre son exécution grâce à
<code>^C</code>, que la plupart des programmes comprennent.<code>^C</code>
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.
</p>

<p>
Vous pouvez pratiquer <code>^C</code>, <code>^Z</code>, <code>fg</code>,
<code>bg</code> de façon visuelle et didactique en lançant la commande 
</p>

<pre>xdaliclock -seconds -geometry 500x100+0+0 -font BUILTIN</pre>

<p class="continue">
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.
</p>

<p>
Résumé :
</p>

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

<h2><a name="ps">Voir les processus</a></h2>

<p>
La commande <code>ps</code> montre où en sont les tâches de fond :
</p>

<pre>
<span class="prompt">chaland ~ $</span> 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</pre>

<p>
<code>ps</code> affiche la liste des processus que vous avez lancés :
</p>

<ul>

<li><code>PID</code> (<em>process identificator</em>) : c'est le numéro du
processus.
</li>
<li><code>TT</code> : 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).
</li>
<li><code>STAT</code> : indique l'état du processus :
<ul>
<li><code>R</code> : actif ( <em>running</em>)</li>
<li><code>S</code> : non activé depuis moins de 20 secondes
  (<em>sleeping</em>)</li>
<li><code>I</code> : non activé depuis plus de 20 secondes (<em>idle</em>)</li>
<li><code>T</code> : arrêté (suspendu)</li>
<li><code>Z</code> : zombie</li>
</ul>
</li>
<li><code>TIME</code> : indique le temps machine utilisé par le programme (et
non pas le temps depuis lequel le processus a été lancé !).
</li>
</ul>

<p>
La commande <code>ps</code> a différentes options, dont les suivantes :
</p>

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

<p>
<code>ps agux</code> est en fait souvent utilisé pour avoir des informations sur
tout les processus.
</p>

<p>
La commande <code>top</code> 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...
Le logiciel KSysGuard, accessible sous la config KDE par la combinaison
de touches <code>^Esc</code>, fait la même chose que <code>top</code> en
mode graphique.
</p>


<h2><a name="kill">Tuer les procesus</a></h2>

<p>
Les programmes ont tous une commande spécifique pour les quitter
(<code>q</code>, 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. 
</p>

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

<pre>
<span class="prompt">chaland ~ $</span> 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
<span class="prompt">chaland ~ $</span> kill 4782
<span class="prompt">chaland ~ $</span> ps
 PID TT STAT TIME COMMAND
 4450 p9 S 0:00 /usr/local/bin/lcsh
 4851 p9 R 0:00 ps</pre>

<p>
<code>kill -9</code> 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.
</p>


<h2><a name="controle">Contrôle des ressources</a></h2>

<p>
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 :
</p>

<ul>

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

<div class="metainformation">
<date value="from git" />
</div>

</body>
</html>