tuteurs.ens.fr/unix/processus.tml

<?xml version="1.0" encoding="ISO-8859-1"?>
<!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<73>me <em>multi-t<>ches</em>, c'est-<2D>-dire qu'il peut ex<65>cuter
plusieurs programmes <20> la fois. Un processus est une instance d'un programme
en train de s'ex<65>cuter, une t<>che. Le shell cr<63>e un nouveau processus pour
ex<EFBFBD>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<65>tre), on peut l'interrompre par <code>Control-C</code>. Ceci
interrompt (d<>finitivement) la commande. On peut aussi ex<65>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> <20> la fin de la
commande&nbsp;; par exemple&nbsp;:
</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<6C>le
avec le shell; dans le second exemple, on met le <code>dvi</code> en t<>che de
fond, ce qui <20>vite d'avoir <20> le relancer <20> chaque modification. 
</p>

<p>
On reprend la main imm<6D>diatement, sans attendre la fin de l'ex<65>cution de
la commande. On peut donc taper d'autres commandes dans le m<>me terminal,
pendant que la pr<70>c<EFBFBD>dente s'ex<65>cute. 
</p>

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

<p>
Comme on vient de le voir, si vous avez pens<6E> <20> terminer votre ligne de
commande par une esperluette, le programme que vous avez lanc<6E> tourne en
arri<EFBFBD>re-plan (<em>background</em>, abr<62>g<EFBFBD> en <code>bg</code>).
</p>

<p>
Si vous avez omis l'esperluette, le programme prend la pr<70>c<EFBFBD>dence sur le shell.
On dit qu'il tourne au premier plan (<em>foreground</em>, abr<62>g<EFBFBD> en
<code>fg</code>).
Les lignes tap<61>es au clavier sont m<>moris<69>es mais ne seront pas ex<65>cut<75>es par le
shell avant que le programme en cours d'ex<65>cution n'ait fini son calcul. Vous
pouvez malgr<67> tout faire passer ce programme en t<>che de fond, gr<67>ce <20> la
manipulation suivante&nbsp;:
</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<70> par le shell, qui suspend
l'ex<65>cution du programme sans d<>truire le processus correspondant. Les
calculs d<>j<EFBFBD> effectu<74>s par ce programme ne sont pas perdus. Dans l'exemple
pr<EFBFBD>c<EFBFBD>dent, si on demande <20> 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 <20> nouveau acc<63>s aux ressources de l'ordinateur.
<EFBFBD> partir de l'<27>tat suspendu, on peut faire passer un programme&nbsp;:
</p>

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

<p>
Son ex<65>cution reprend alors l<> o<> on l'avait laiss<73>e.
</p>

<p>
Quand il n'y a qu'un seul programme en arri<72>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<65>cution gr<67>ce <20>
<code>^C</code>, que la plupart des programmes comprennent.<code>^C</code>
n'affecte que l'<27>ventuel unique programme qui tourne au premier plan dans le
terminal o<> il est tap<61>. Quand il y en a plusieurs, c'est un peu plus
compliqu<EFBFBD>, 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<66>on visuelle et didactique en lan<61>ant la commande 
</p>

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

<p class="continue">
et en observant attentivement les secondes (pensez <20> en laisser
quelques-unes s'<27>couler). Vous remarquerez que ce programme finit la
transition en cours avant de se remettre <20> l'heure.
</p>

<p>
R<EFBFBD>sum<EFBFBD>&nbsp;:
</p>

<ul>
<li>Le programme tourne au premier plan&nbsp;:
 <ul> 
 <li><code>^Z</code> le suspend&nbsp;;</li>
 <li><code>^C</code> l'interrompt.</li>
 </ul>
</li>
<li>Le programme est suspendu&nbsp;:
 <ul>
 <li><code>fg</code> le passe au premier plan&nbsp;;</li>
 <li><code>bg</code> le passe en arri<72>re-plan.</li>
 </ul>
</li>
<li>Le programme tourne en arri<72>re-plan&nbsp;:
 <ul>
 <li>si c'est le seul dans ce cas, <code>fg</code> le passe au premier plan&nbsp;;</li>
 <li>sinon, c'est plus compliqu<71>.</li>
 </ul>
</li>
<li>Le programme ne tourne pas&nbsp;:
 <ul>
 <li>il n'y a rien <20> 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&nbsp;:
</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<6E>s&nbsp;:
</p>

<ul>

<li><code>PID</code> (<em>process identificator</em>)&nbsp;: c'est le num<75>ro du
processus.
</li>
<li><code>TT</code>&nbsp;: indique le terminal dans lequel a <20>t<EFBFBD> lanc<6E> le processus.
Un point d'interrogation signifie que le processus n'est attach<63> <20> aucun
terminal (par exemple les d<>mons).
</li>
<li><code>STAT</code>&nbsp;: indique l'<27>tat du processus&nbsp;:
<ul>
<li><code>R</code>&nbsp;: actif ( <em>running</em>)</li>
<li><code>S</code>&nbsp;: non activ<69> depuis moins de 20 secondes
  (<em>sleeping</em>)</li>
<li><code>I</code>&nbsp;: non activ<69> depuis plus de 20 secondes (<em>idle</em>)</li>
<li><code>T</code>&nbsp;: arr<72>t<EFBFBD> (suspendu)</li>
<li><code>Z</code>&nbsp;: zombie</li>
</ul>
</li>
<li><code>TIME</code>&nbsp;: indique le temps machine utilis<69> par le programme (et
non pas le temps depuis lequel le processus a <20>t<EFBFBD> lanc<6E>&nbsp;!).
</li>
</ul>

<p>
La commande <code>ps</code> a diff<66>rentes options, dont les suivantes&nbsp;:
</p>

<ul>
<li><code>a</code> (<em>all</em>)&nbsp;: donne la liste de tous les processus, y
compris ceux dont vous n'<27>tes pas propri<72>taire.
</li>
<li><code>g</code> (global, g<>n<EFBFBD>ral...)&nbsp;: donne la liste de tous les processus
dont vous <20>tes propri<72>taire.
</li>
<li><code>u</code> (<em>user</em>, utilisateur)&nbsp;: donne davantage
d'informations (nom du propri<72>taire, heure de lancement, pourcentage de
m<EFBFBD>moire occup<75>e par le processus, etc.).
</li>
<li><code>x</code>&nbsp;: affiche aussi les processus qui ne sont pas associ<63>s <20> un
terminal.
</li>
<li><code>w</code>&nbsp;: le tronque pas <20> 80 caract<63>res (peut <20>tre utilis<69>e plusieurs fois pour tronquer plus loin)
</li>
</ul>

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

<p>
La commande <code>top</code> affiche les m<>mes informations, mais de fa<66>on
dynamique&nbsp;: 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<74>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<73>cifique pour les quitter
(<code>q</code>, menu o<> cliquer, etc). C'est seulement dans le cas o<> vous
ne parvenez pas <20> 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 <20>a ne marche pas, utilisez la commande <code>kill</code> (plus le
num<EFBFBD>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 <20> tous les coups. Vous ne pouvez tuer que
les processus dont vous <20>tes propri<72>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<74>le des ressources</a></h2>

<p>
La possibilit<69> d'ex<65>cuter plusieurs commandes <20> la fois (et aussi sur
plusieurs machines) pose un probl<62>me imm<6D>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&nbsp;: il peut arriver (et il
est arriv<69>) qu'il ne puisse m<>me plus se connecter. Voil<69> quelques outils
pour vivre paisiblement&nbsp;:
</p>

<ul>

<li><code>nice</code> ex<65>cute un programme <20> priorit<69> plus basse (faire
<code>man nice</code>).
</li>
<li><code>limit</code> commande interne du shell, permet de limiter les
ressources <20> disposition de votre processus (tr<74>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">
Derni<EFBFBD>re modification le <date value="$Date: 2007-07-13 08:41:22 $" />.
</div>

</body>
</html>