Conversion de processus.html.
This commit is contained in:
george
parent
03323e3fec
commit
3289c84a96
1 changed files with 288 additions and 0 deletions
288
unix/processus.tml
Normal file
288
unix/processus.tml
Normal file
|
|
@ -0,0 +1,288 @@
|
|||
<?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è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>&</code> à la fin de la
|
||||
commande ; par exemple :
|
||||
</p>
|
||||
|
||||
<pre>
|
||||
<span class="prompt">chaland ~ $</span> cc -o grosprogramme grosfichier.c &
|
||||
|
||||
<span class="prompt">chaland ~ $</span> xdvi monrapport.dvi &</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> : le tronque pas à 80 caractères (peut être utilisée plusieurs fois pour tronquer plus loin)
|
||||
</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...
|
||||
</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">
|
||||
Dernière modification le 2002-11-23.
|
||||
</div>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
Loading…
Add table
Reference in a new issue