Norman Matloff
Department of Computer Science
University of California at Davis
8 November 1999

Translation by eberkut - http://www.chez.com/keep

Sommaire

1 Processus Unix
2 Déterminer des informations concernant les processus en cours
3 Processus d'Avant-plan/Arrière-plan
4 Terminer un processus

1  Processus Unix

Un processus est une instance d'un programme en fonction. Si, par exemple, 3 personnes font tourner le même programme simultanément, il y a 3 processus, pas juste 1. En fait, Nous pourrions avoir plus d'un processus en fonction avec seulement une personne exécutant le programme, parce que (vous le verrez plus tard) le programme peut couper en 2, engendrant 2 processus à partir d'un.

Gardez à l'esprit que toute commande Unix, par exemple cc et ls sont des programmes et ainsi contribues aux processus du système lorsqu'ils fonctionnent. Si 10 utilisateurs font fonctionner ls maintenant, il y aura 10 processus. A n'importe quel moment, un système Unix typique aura beaucoup de processus actifs, dont certains présents depuis la première mise sous tension de la machine.

A chaque fois que vous entrez une commande, Unix démarre un nouveau processus, et suspend le processus actuel (C-shell) jusqu'à ce que le nouveau processus se termine (excepté dans le cas des processus de fond, expliqué plus tard).

Unix identifie chaque processus par un Process Identification Number (PID) qui est assigné au lancement du processus. Quand nous voulons exécuter une opération sur un processus, nous nous réferons habituellement à lui par son PID.

Unix est un système à temps partagé, ce qui signifie que les processus s'exécutent par cycle. Chaque cycle est appelé un timeslice ; sur beaucoup de systèmes il vaut beaucoup moins d'une seconde. La raison de l'utilisation de cette approche exécution par cycle est l'équitablement : Nous ne voulons attendre le temps d'une tâche de 5 heures pour une tâche de 2 secondes, ce qui se produirait si une tâche avait l'unité arithmétique de traitement pour lui seul jusqu'à ce qu'il soit terminé.*

2 Déterminer des informations sur les processus en cours

La commande "ps -x" The `ps -x' liste toutes les tâches en cours. Un exemple est :

  PID TT STAT  TIME COMMAND
 6799 co IW    0:01 -csh[rich] (csh)
 6823 co IW    0:00 /bin/sh /usr/bin/X11/startx
 6829 co IW    0:00 xinit /usr/lib/X11/xinit/xinitrc --
 6830 co S     0:12 X :0
 6836 co I     0:01 twm
 6837 co I     0:01 xclock -geometry 50x50-1+1
 6841 p0 I     0:01 -sh[rich on xterm] (csh)
 6840 p1 I     0:01 -sh[rich on xterm] (csh)
 6842 p2 S     0:01 -sh[rich on login] (csh)
 6847 p2 R     0:00 ps -x

La signification des noms de ces colonnes est la suivante :

PID         process identification number
TT          terminal de contrôle du processus
STAT        état de la tâche
TIME        quantité de temps CPU que le processus a utilisé jusqu'ici
COMMAND     nom de la commande dont est issu le processus 

L'information TT donne le nom du terminal, que vous pouvez voir en tapant la commande who. Par exemple, nous lisons p2 dasn la colonne TT au-dessus, E.g. we see p2 in the TT column above, ce qui est énuméré comme ttyp2 par la commande who.

L'état de la tâche est donné par une séquence de 4 lettres, par exemple, "RWNA". La première de ces 4 lettre est généralement une des suivantes :

R processus en cours
T processus stoppé
S processus endormi pour moins de 20 secondes
I processus en veille (endormi plus de 20 secondes)

Un processus en état R est utilisable, c-a-d  qu'il peut être utilisé pour effectuer ou attendre son cycle.

Nous pouvons mettre un processus en état T, c-a-d stopper le processus, en entrant ctrl-z. Supposons, par exemple, que j'utilise FTP pour prendre des fichiers ou des archives d'un site, et je note un fichier appelé README. Je peux utiliser la commande FTP "get" pour prendre le fichier README, puis entrer ctrl-z. Cela va stopper (suspendre) le processus FTP, et me renvoyer au C-shell. A ce moment je peux lire le fichier README, utilisezt "more", puis ractivé le processus ftp en tapant "fg" dans le shell.

Un exemple typique d'un processus en état S/I est l'attendre d'une entrée d'un utilisateur. Si j'utilise l'éditeur Emacs, par exemple, le processus ira a l'état S quand il attendra que je tape quelque chose ; si je prends plus de 20 secondes à décider quoi taper, le processus ira en état I.

3  Processus d'Avant-plan/Arrière-plan

Supposons que nous voulons exécuter une command mais nous ne voulons pas attendre qu'il s'accomplisse, c-a-d nous voulons pouvoir entrer d'autres commandes dans le même temps. Nous pouvons le faire en spécifiant que la commande doit être exécuté en arrière-plan.

Il y a 2 manières de le faire. La première est de spécifier que ce soit un processus d'arrière-plan lorsque nous l'appelons, ce que nous pouvons faire en ajoutant un "&" à la fin de la commande. Par exemple, supposons que nous avons un très gros programme, que nous allons mettre beaucoup de temps à la compiler. Nous pouvons entrer la commande

cc bigprog.c &

Ce qui exécutera la compilation en me laissant entrer d'autres commandes pour l'exécution pendant que la compilation se poursuit. Le C-shell me permettra de savoir quel est le PID pour ce processus en arrière-plan (donc plus tard, je peux le surveiller en utilisant "ps", o le tuer), mais me donnera également ma requête régulière, m'invitant à entrer d'autres nouvelles commandes pendant que l'autre fonctionne.*

Mais qu'en est-il des messages d'erreur du compilateur ? Nous espérons n'en avoir aucun :-) mais si nous devons en avoir, nous ne voulons qu'ils intercède avec les sorties des autres commandes lancées pendant que la compilation est exécutée. Pour éviter ceci, nous redirigeons les messages d'erreur :

cc bigprog.c >& errorlist &

Tous les messages d'erreur seront désormais envoyé au fichier "errorlist", que nous pourrons voir plus tard.*

Un autre bon exemple est quand nous ouvrons une fenêtre durant une session X. Nous souhaiterions ouvrir la fenêtre depuis une fenêtre existante, mais nous voulons toujours avoir la possibilité d(utiliser la fenêtre originale. Nous exécutons la commande

xterm &

Ceci ouvrira une nouvelle fenêtre, and nous laissera continuer d'utiliser la fenêtre en cours.

L'autre méthode pour mettre une tâche en arrière-plan est de l'arrêter, en utilisant ctrl-z comme décrit précédemment, puis utiliser une autre commande, "bg", pour mettre le processus en arrière-plan.

Par exemple, supposons que nous lançons notre longue compilation,

cc bigprog.c

Mais nous avons oublié de mettre le "&". Nous pouvons taper ctrl-z pour suspendre/stopper la tâche, puis taper "bg" pour reprendre la tâche en arrière-plan, nous autorisant à soumettre d'autres commandes pendant que la compilation reprend sa place. Unix nous dira quand la tâche de fond sera finie, avec un rapport comme

[1]    Done                 cc bigprog.c

Par ailleurs, si vous vous déconnecté, pas de problèmes, les processus en arrière-plan que vous avez lancez ne sera pas tuer ; ils poursuivront leur travail.

4  Terminer un processus

Nous pouvons terminer un processus en utilisant la commande "kill". Nous devons simplement trouver son PID (utilisez "ps"), puis taper

kill -9 pid

Si le processus est en avant-plan, réfléchissez, la façon la plus facile de le tuer et de simplement taper ctrl-C

Notes :

* Le mécanisme basique pour configurer les cycles est le suivant. La machine aura une pièce de hardware qui enverra des impulsions électriques au CPU à des intervalles réguliers et périodiques. Ces impulsions forcent le CPU a arrêter le programme en cours, et a passer à un autre programme, qui sera le programme du système d'exploitation (Operating SYstem, OS). L'OS peut alors déterminer si le timeslice du programme en cours est terminé, and si c'est le cas, donner le cycle à un autre programme. Notez ici l'interaction hardware (impulsions électriques et la réaction du CPU à eux)/Software (l'OS).

* Gardez à l'esprit qu'il n'y a pas de repas gratuit ici. Plus il y aura de processus sur la machine, plus il faudra de cycles pour chaque processus, donc le temps réponse global baissera.

* Cependant, une solution bien meilleure consiste à utiliser Emacs, puisque les messages d'erreur seront automatiquement placés dans une mémoire tampon spéciale.