Vous êtes sur la page 1sur 27

Niveau: LF-SI1

A.U: 2020-2021

Notes du cours : systèmes


d’exploitation

de

Mme Manel SEKMA


Références:
1.Systèmes d'exploitation: Collection Synthex Informatique: Synthèse de cours & exercices corrigés,
Bart Lamiroy, Laurent Najman, Hugues Talbot. (Auteurs)
2.Systèmes d'exploitation 3ème Ed, 2008 de Andrew Tanenbaum (Auteur)

1
NB: Ce document doit être complété par les notes du cours
Notes du cours : systèmes d’exploitation
Niveau: LF-SI1 de Mme Manel SEKMA

A.U: 2020-2021

Chapitre 2 Les Threads


1. Processus Vs Threads

2. Intérêt des threads

3. Etats d'un Thread

4. Modèles des Threads

5. Services Posix de gestion de threads


2 Systèmes d'exploitation
NB: Ce document doit être complété par les notes du cours
Processus Vs Threads
 Le problème d'un processus c'est que c'est un peu lourd, cela implique:
• des recopies de mémoire,

de passer par le système pour communiquer avec d'autre
processus.
 Il existe donc un autre concept nommé thread
 Un thread, c'est « un découpage d'un processus ».
 Cela veut dire qu'il utilise exactement la même …………qu'un processus,
ainsi que les mêmes descripteurs de fichiers.

3 Systèmes d'exploitation
Processus Vs Threads
 Un processus possède un espace d’adressage et un thread de
contrôle unique.
 Un thread –processus léger ou leightweight process inclut :
 Un …………...... qui effectue le suivi des instructions à
exécuter
 Des …………….., qui détiennent les variables en cours.
 Une ………….., qui contient l’historique de l’exécution.

 Multithreading: +sieurs threads dans le même espace d’adressage.

4 Systèmes d'exploitation
Processus Vs Threads
 Données par processus et par thread

Éléments par processus Éléments par thread


Espace d'adressage Compteur ordinal (PC)
Variables globales Registres
Fichiers ouverts Pile
Processus enfant État
Alertes en attente
Signaux et gestionnaires de
signaux
………

5 Systèmes d'exploitation
Intérêt des threads
 Dans une application, plusieurs activités s’exécutent en parallèle
 Les threads sont un bon modèle de programmation
 Comme les processus ☺
 Les threads partagent le même espace mémoire
 Indispensable pour certaines applications
 Les threads ont peu d’information propre
 Très faciles à créer/détruire
 En général, 100 fois plus rapide à créer qu’un processus
 Permettent de recouvrir le calcul et les I/Os
 Si les threads font que du calcul, peu d’intérêt
 Très pratiques sur les systèmes multi CPU

6 Systèmes d'exploitation
… Trait de Texte multithreaded

Thread 1: remet en forme le document


Thread 2: interaction avec l’utilisateur
Thread 3: écrit périodiquement le contenu de la RAM sur le disque
7 Systèmes d'exploitation
… Serveur Web multithreaded
 Les pages web les + consultées sont
dans le cache.
 Le dispatcher lit les requêtes entrantes
 Le worker vérifie le cache, sinon
effectue un read sur le disque, donc
devient bloqué sur une E/S

Dispatcher Worker
while (TRUE) { while (TRUE) {
get_next_request(&buf); wait_for_work(&buf);
handoff_work(&buf); look_for_page_in_cache(&buf, &page);
} if (page_not_in_cache(&page))
read_page_from_disk(&buf, &page);
8 Systèmes d'exploitation return_page(&page);
}
Etats d'un Thread
Création
Exécution

Suspendu Activation Prêt Bloqué


Réveil
(fin d’E/S)

Tué détruit
destruction

9 Systèmes d'exploitation
Etats d'un Thread
Transitions états d'une thread

 Exécution  bloqué (mise en attente)


Thread doit arrêter son exécution pour attendre l'arrivée d'un
événement (fin d'E/S)
=> libère volontairement [ressource] CPU
=> SE alloue CPU a thread prêt le + prioritaire
 Bloqué  prêt (réveil)
 Thread réveillé [par événement]
 Rejoint groupe des demandeurs ressource CPU

10 Systèmes d'exploitation
Etats d'un Thread
Transitions états d'une thread

 Prêt  élu (élection)


 CPU attribué au thread prêt le + prioritaire
=> l’autre thread est préempté par SE
 Elu  prêt (préemption)
 CPU retiré du thread en exécution pour être attribuer au thread le +
prioritaire

11 Systèmes d'exploitation
Modèles des Threads
 Soit dans l’Espace Utilisateur ou dans le Noyau

12 Systèmes d'exploitation
Modèles des Threads
Implémentation de Threads dans l’espace utilisateur
 Implique que le partage des ressources de traitement se fait
entièrement en espace utilisateur
 le noyau n'a aucune connaissance de la présence de
threads dans les processus.
 Il y a un thread noyau pour chaque processus, peu importe le
nombre de threads en exécution de celui-ci.
 Chaque processus a besoin de sa propre table de threads dont
les enregistrements contiennent les registres, le compteur ordinal,
le pointeur de pile, l'état, etc. de chaque threads!
 Lorsqu'un thread est bloqué, ses registres sont enregistrés dans la
table et un autre thread est choisi, ses registres sont chargés et il
est prêt
13 Systèmes d'exploitation
Modèles des Threads
Implémentation de Threads dans l’espace utilisateur

 le processus a son propre algo d’ordonnancement entre les


threads.
 Plateforme utilisant les threads en espace utilisateur :

 GNU Portable thread


 JAVA (sur certaines JVM)
 C#
 ….

14 Systèmes d'exploitation
Modèles des Threads
Implémentation de Threads dans l’espace utilisateur
Avantages Inconvénients
 Les commutations de contextes  Cette approche ne permet pas d'utiliser les
sont plus rapides. avantages du multithreading sur les
 Indépendant du système machines multiprocesseurs.
d'exploitation.  Un seul thread par processus ne s'exécute à
 L'ordonnancement peut être la fois (même sur une machine
adapté (plus flexible). multiprocesseurs).
 Ne règle pas les problèmes de blocage en
entrées-sortie.

15 Systèmes d'exploitation
Modèles des Threads
Implémentation de Threads dans l’espace noyau

 Implique que c'est le SE qui gère les threads.

 Un thread noyau existe pour chaque thread à l'intérieur des


processus: Les threads sont alors des objets du noyau.

 Il s'agit de l'implémentation la plus simple. Puisqu'il est relativement


lourd de créer et détruire des threads noyau, plusieurs systèmes
d'exploitation les recyclent.
 si un thread meurt, l'ordonnanceur le marque comme non exécutable.
Lorsqu'un nouveau thread est créé, ce thread non-exécutable est réactivé.

16 Systèmes d'exploitation
Modèles des Threads
Implémentation de Threads dans l’espace noyau

 C'est l'ordonnanceur du SE qui partage les ressources de


traitements, qui effectue les commutations de contexte, change les
threads d'état, etc.

 Plateforme utilisant les threads en espace noyau :


 Windows
 Linux (avec la librairie usuelle)
 Solaris
 Native POSIX Thread Library (NPTL)

17 Systèmes d'exploitation
Modèles des Threads
Implémentation de Threads dans l’espace noyau

• Avantages • Inconvénients

• Utilisation optimisée des ressources • La commutation de contexte est plus lourde.


de traitements (multiprocesseurs).
• La gestion (création, attente, synchronisation) des
• Possibilité d'utiliser les interruptions. threads nécessite des appels systèmes.

• Réutilisation de fonctions éprouvées • L'interface peut-être dépendante du système


du système d'exploitation. exploitation.
• lors d'un défaut de page (ou lors d'un appel
système), le processus au complet est bloqué au
lieu de seulement le thread en problème.

18 Systèmes d'exploitation
Modèles des Threads
Implémentation de Threads en hybride utilisateur / noyau
 L'implémentation hybride utilise N threads noyau qui exécute M threads
utilisateur (N < M).
 L'objectif est d'utiliser les avantages des threads utilisateurs et les
fonctionnalités des threads noyau en évitant les désavantages de chacun.
 Ils sont plus difficiles à implanter puisqu'ils nécessitent du code utilisateur et
noyau.
 Plusieurs threads en espace utilisateur sont exécutés par un thread en espace
noyau. Un même processus peut ainsi disposer de plusieurs threads noyau.

19 Systèmes d'exploitation
Services Posix de gestion de threads

 Une interface standard définie en POSIX (Portable Operating System


Interface) Threads qui force le support d'une centaine de fonction sur la
gestion des threads, les mutex, les variables de conditions (moniteurs) et la
synchronisation.
 La norme POSIX définit notamment :
 Les commandes shell de base (ksh, ls, man, ...)
 L’API (Application Programming Interface) des appels système.
 L’API des threads

 Les fonctions liées aux threads sont dans la bibliothèque pthread.h, et il faut
compiler avec la librairie libpthread.a:
Exemple: $ gcc -lpthread monprog.c -o monprog

20 Systèmes d'exploitation
Services Posix de gestion de threads
Création de Threads
 Pour créer un thread, il faut créer une fonction qui va s’exécuter dans le thread, qui a
pour prototype :
void *ma_fonction_thread(void *arg);

 On crée ensuite le thread par un appel à la fonction pthread_create, et on lui passe en


argument la fonction :

int pthread_create (pthread_t *thread , pthread_attr_t * attributs, void * ma_fonction_thread, void *arg );

où :
• Le premier argument (thread) est un passage par adresse de l’identifiant du thread (de type
pthread_t). La fonction pthread_create nous retourne ainsi l’identifiant du thread, qui l’on utilise
ensuite pour désigner le thread.
• Le deuxième argument (attributs) désigne les attributs du thread, et on peut mettre NULL pour
avoir les attributs par défaut.
• Le troisième argument est un pointeur sur la fonction à exécuter dans le thread (ma_fonction_thread ;
• Le quatrième argument (arg) est l’argument de la fonction de thread.
Services Posix de gestion de threads
Suspension de Thread
 Le processus qui exécute le main (l’équivalent du processus père) est aussi un thread et
s’appelle le thread principal. Le thread principal peut attendre la fin de l’exécution d’un
autre thread par la fonction pthread_join (similaire à la fonction wait dans le fork).
 Cette fonction permet aussi de récupérer la valeur retournée par la fonction
ma_fonction_thread du thread.

int pthread_join(pthread_t *thid, void **valeur_de_retour);

où :
• Le premier paramètre (thid) est l’identifiant du thread (que l’on obtient dans
pthread_create) ; (Le thread à attendre)
• Le second paramètre (**valeur_de_retour) est un passage par adresse d'un pointeur qui
permet de récupérer la valeur retournée par ma_fonction_thread.
La fonction pthread_join() suspend l’exécution d’un thread principal jusqu’à ce que termine le
thread avec l’identificateur thid.
22 Systèmes d'exploitation
Services Posix de gestion de threads
Terminaison de Thread

void pthread_exit(void *valeur_de_retour);

 La fonction pthread_exit() permet à un processus léger de terminer son


exécution, en retournant l’état de terminaison

Note: intptr_t est un type entier signé optionnel pouvant représenter une adresse.
23 Systèmes d'exploitation
Services Posix de gestion de threads
 Exercice1: crée un thread qui lit une valeur entière et la retourne au main. ‘exercice4)
int main(void) {
#include <pthread.h> int ret_th;
#include <stdio.h> void *ret_fc ;
#include <stdlib.h> int ret_fc1;
#include <unistd.h> pthread_t my_thread;
#include <time.h> ret_th=pthread_create(&my_thread,NULL,
void *ma_fonction_thread(void *arg) { ma_fonction_thread, NULL);
int resultat; printf(" la valeur retournée du thread :
void * x; %d\n",ret_th);
printf("Je suis un thread.Veuillez entrer un entier\n"); if (ret_th != 0)
scanf("%d",&resultat); { fprintf(stderr, "Erreur de création du thread");
x = (void *) (intptr_t) resultat; exit (1);}
pthread_exit((void*)x); pthread_join(my_thread,&ret_fc);
} ret_fc1 = (int) (intptr_t) ret_fc;
printf("Dans le main, la valeur retournée de la
fonction du thread : %d\n", ret_fc1);
24 Systèmes d'exploitation return 0;}
Services Posix de gestion de threads
 Exercice 2: Ecrire un programme pthreads qui permet de créer 8 threads, chaque
thread affiche le message « bonjour tout le monde » avec une langue différente.
Soit :
Thread 0 affiche "English: Hello World!";
Thread 1 affiche "French: Bonjour, le monde!";
Thread 2 affiche "Spanish: Hola al mundo";
Thread 3 affiche "Klingon: Nuq neH!";
Thread 4 affiche "German: Guten Tag, Welt!";
Thread 5 affiche "Russian: Zdravstvuyte, mir!";
Thread 6 affiche "Japan: Sekai e konnichiwa!";
Thread 7 affiche "Latin: Orbis, te saluto!";

25 Systèmes d'exploitation
Services Posix de gestion de threads

26 Systèmes d'exploitation
Réponse
#include <pthread.h>
#include <stdio.h> messages[0] = "English: Hello World!";
#include <stdlib.h> messages[1] = "French: Bonjour, le monde!";
messages[2] = "Spanish: Hola al mundo";
#define NUM_THREADS 8
messages[3] = "Klingon: Nuq neH!";
messages[4] = "German: Guten Tag, Welt!";
char *messages[NUM_THREADS]; messages[5] = "Russian: Zdravstvuyte, mir!";
messages[6] = "Japan: Sekai e konnichiwa!";
void *PrintHello(void *threadid) messages[7] = "Latin: Orbis, te saluto!";
{
long taskid; for(t=0;t<NUM_THREADS;t++) {
//sleep(1); taskids[t] = t;
taskid = (long) threadid; printf("Creating thread %d\n", t);
rc = pthread_create(&threads[t], NULL, PrintHello, (void *)
printf("Thread %d: %s\n", taskid, messages[taskid]); taskids[t]);
pthread_exit(NULL); if (rc) {
} printf("ERROR; return code from pthread_create() is %d\n", rc);
exit(-1);
int main(int argc, char *argv[]) }
{ }

pthread_t threads[NUM_THREADS];
pthread_exit(NULL);
long taskids[NUM_THREADS];
}
int rc, t;

27 Systèmes d'exploitation

Vous aimerez peut-être aussi