===========================
 Les processus et les flux
===========================

Les processus
=============

Processus est le nom générique que l'on donne à tout programme (commande, application, script) qui s'exécute sur le système d'exploitation. 

Chaque programme peut se composer d'un ou plusieurs processus. Lorsqu'il se compose de plusieurs processus, on parle de *threads*. 

Chaque processus qui s'exécute sur la machine a un identifiant (le PID), un propriétaire (l'utilisateur qui a déclenché l'exécution du processus) et un processus parent identifié par un PPID. 

Voici quelques commandes qui permettent de manipuler des processus, et que vous devez expérimenter : 

* ``&`` : placé après le nom du programme à exécuter permet d'exécuter celui-ci en tâche de fond, et donc de récupérer la main dans le terminal. 
* ``bg`` : suivi du numéro du processus, permet de mettre le processus en arrière plan (*background*)
* ``fg`` : suivi du numéro du processus, permet de mettre le processus au premier plan (*foreground*)
* ``Ctrl-Z`` : passe un processus en arrière plan et suspend son exécution
* ``jobs`` : affiche les processus exécutés dans le terminal en cours
* ``top`` : affiche la liste des processus en cours d'exécution, ainsi que des informations sur la mémoire et le temps processeur qu'ils occupent 
* ``ps`` : affiche une sélection de processus selon les critères définis par les options (``-e`` pour tous les processus, ``-H`` pour avoir une visualisation arborescente; etc.)
* ``Ctrl+C``, ``kill``, ``killall`` : permet de tuer des processus
* ``sleep`` : effectue une pause de la durée passée en paramètre. 

Les flux
========


Pour s'exécuter, un processus doit recevoir des données,
et transmettre des résultats. Parfois, il déclenche
également des erreurs. Ces données, ces résultats et
ces erreurs constituent des **flux** que le processus
utilise pour communiquer avec l'extérieur.

On distingue trois type de flux :

* l'entrée standard, **stdin** (défaut : le clavier, descripteur 0);
* la sortie standard, **stdout** (défaut : l'écran, descripteur 1);
* la sortie d'erreur **standard**, stderr (défaut : l'écran, descripteur 2)

Des opérateurs permettent de manipuler les flux :

* ``>`` : redirige la sortie du processus à gauche du signe vers le fichier à droite. Si le fichier n'existe pas, il est créé, s'il existe, son contenu est détruit et remplacé par le nouveau contenu
* ``>>`` : fonctionne comme le précédent, mais ajoute le nouveau contenu à la suite de l'ancien
* ``<`` : utilise le fichier de droite en tant que stdin
* ``2>`` : redirige stderr vers un fichier en le créant ou en l'écrasant s'il existe 
* ``2>>`` : redirige stderr vers un fichier en le créant ou en écrivant à la fin s'il existe. 


Les **tubes** :

La commande ``|`` (*pipe* en anglais) permet à deux processus (locaux) de communiquer. En pratique, cette commande redirige la sortie du premier processus vers l'entrée du second. En d'autres termes, ``|`` permet d'utiliser le stdout d'une commande comme stdin d'une autre commande. 

Par exemple, la commande suivante va afficher toutes les lignes du fichier ``test.txt`` contenant le mot "todo" ::

  cat test.txt | grep "todo"


Les **sockets** : 

Les sockets sont des tubes entre deux processus distants. Ils sont caractérisés par un numéro de port et une adresse IP. Vous étudierez les sockets en programmation système. 


.. toctree::
   :maxdepth: 2

   processus_exos.rst
   redirections_exos.rst