Main 3

Gestion de thread
Pthread (POSIX Thread)
Système d’exploitation
Module: M18 - IRISI S3
Pr. Abdessamad EL BOUSHAKI

abdessamad.elboushaki@gmail.com
FST Marrakech
Université Cadi Ayyad
Pr. Abdessamad EL BOUSHAKI (FST Marrakech) Système d’exploitation 1/54

Gestion de thread
Gestion de thread

Gestion de thread
Processus : rappel
Unité de calcul
I dont les caractéristiques sont stockées dans un PCB
I possédant un espace mémoire propre
Nécessite des mécanismes de communications complexes (mis en place par

le SE)
Commutation de contexte coûteuse

Gestion de thread
Notion de thread
Définition
Thread ("processus léger") : unité d’exécution rattachée à un processus
(interne à un processus), chargée d’exécuter une partie du processus.

Gestion de thread
Notion de thread
Un thread possède une série d’informations propres à lui

I un identifiant
I un compteur d’instructions
I un ensemble de registres
I une pile
Un thread partage avec les threads du même processus

I La zone de code
I La zone de données
I Les ressources du système d’exploitation (fichiers ouverts et signaux)
Mécanisme simple de passage entre threads

Gestion de thread
Utilisation des threads
Exemple d’utilisation des threads :
Distinction travail avant-plan/arrière-plan, asynchrone

I Éditeur de texte avec sauvegarde régulière
Vitesse d’exécution
I Traiter un lot de données, lire le suivant
Structure modulaire de programme

I Découpe d’un programme en fonctionnalités
Fonction à exécuter plusieurs fois en parallèle

I Serveur web par exemple

Gestion de thread
Processus mono- et multi-threads
Processus mono-thread
Un processus mono-thread est un programme qui s’exécute selon un
chemin unique (Compteur Ordinal ).
On dit qu’il a un flot de contrôle unique (un seul thread).
Processus multi-thread
De nombreux systèmes d’exploitation modernes offrent la possibilité
d’associer à un même processus plusieurs chemins d’exécution.
On parle du multi-thread qui permet d’exécuter simultanément des parties
d’un même processus.
Chaque partie correspond à un chemin d’exécution du processus.

Gestion de thread
Processus mono- et multi-threads

Gestion de thread
Processus multi-thread
Une application est implémentée comme un processus

I Par exemple, un web browser prend la forme d’un processus
I Un processus est composé de threads de contrôle
I Affiche des images et reçoit des informations du réseau
Peut exploiter les CPU multi-cœurs

I Calcul intensif, un thread d’exécution par cœur
Les threads évitent de devoir créer un nouveau processus

I Effectuer la même tâche peut se faire avec un thread

Gestion de thread
Avantages du multi-threading
Parmi les avantages du multi-threading :

Augmentation de la réponse (Réactivité)
I Le processus peut continuer à s’exécuter même si certaines de ses threads
sont bloquées
Partage des ressources du processus
I Les différents threads sont dans l’espace d’adressage du processus, ce qui
permet de faciliter la coopération, et donc améliorer la performance
Économie d’espace mémoire et de temps
I Il faut moins de temps pour créer et terminer un thread et pour commuter
entre deux threads d’un même processus
I Ex. sous Solaris, la création d’un processus est 30 fois plus lente que celle
d’un thread
Montée en charge sur des architectures multi-processeurs
I Les threads peuvent être exécutés sur différents processeurs

Gestion de thread
possibles combinaisons "Processus - threads"

Gestion de thread
Table des threads
Lorsqu’un processus est créé, un seul thread (qui exécute le programme

principal, habituellement la fonction main) est associé au processus.
Ce thread (appelé le thread principal) peut en créer d’autres threads

(appelés threads secondaires).
L’ensemble de tous les threads créés est enregistré dans une table appelé
«table des threads».
Chaque entrée de cette table contient une structure de données particulière

appelé bloc de contrôle de thread (TCB : Threads Control Bloc)

Gestion de thread
Bloc de contrôle de thread : TCB
Comme le PCB, le TCB contient des informations nécessaire à :
L’exécution du thread appelé le contexte d’un thread. Ce contexte permet

de reprendre l’exécution d’un thread qui a été interrompu.
Informations nécessaires à la gestion du thread.

Gestion de thread
TCB : Contexte du thread
Le processus est vu comme étant un

ensemble de ressources que ses
threads partagent :
I Code exécutable
I Segment de données
I Segment de fichiers
I Segment de périphériques
I etc.
Chaque thread a cependant, en plus
des ressources communes :
I sa propre zone de données
(variables locales)
I sa propre pile d’exécution
I ses propres registres
I et son propre compteur ordinal

Gestion de thread
TCB : Informations de gestion
Le TCB contient des informations du thread permettant l’identification et la

gestion du thread. On peut trouver:
I Identificateur du thread (TID)
I Priorité
I Etat du thread
I Quantum restant à consommer
I Pointeurs sur TCB des threads parents (père, fils,...)
I Informations sur l’état des Entrées/Sorties
I etc.

Gestion de thread
États d’un thread

Comme le processus, le thread peut passer par plusieurs états (Nouveau
(NEW), Prêt (READY), En exécution, Élu ou Actif (RUNNING), En
attente ou Bloqué (WAITING), Terminé (TERMINATED)):
I Les threads Prêts attendent dans le processus
I Le thread Actif est choisit selon une politique de scheduling. Il l’exécute
quand le processus est actif

Gestion de thread
Types de thread
Le support pour les threads peut être fourni à deux niveaux

Thread niveau utilisateur (ULT)
I Gestion intégralement faite par l’application
Thread niveau noyau (KLT)
I Le noyau est multi-threads, ils sont gérés par l’OS
L’implémentation des liens entre les threads utilisateurs et les threads noyaux
varie considérablement d’une plateforme à une autre. On distingue trois modèles
de multi-threading :
Plusieurs-vers-un : plusieurs threads utilisateur vers un thread noyau
Un-vers-un : un thread utilisateur vers un thread noyau
Plusieurs-vers-plusieurs : plusieurs threads utilisateur vers plusieurs threads
noyau

Gestion de thread
Thread utilisateur
Les threads utilisateur sont implantés dans une bibliothèque logicielle
(niveau utilisateur ) qui fournit un support pour les gérer.
I Ex. Les threads Java sont gérés par la machine virtuelle Java (JVM).
Les threads utilisateur ne sont pas gérés par le noyau; Le noyau gère les
processus (table des processus) et ne se préoccupe pas de l’existence des
threads
I Lorsque le noyau alloue le processeur à un processus, le temps d’allocation du
processeur est réparti entre les différents threads du processus (cette
répartition n’est pas gérée par le noyau).

Gestion de thread
Thread utilisateur
Avantages
I Les threads utilisateur sont généralement créés, et gérés rapidement.
I Ordonnancement géré par l’application : flexibilité.
I Ils facilitent la portabilité (Indépendants de système d’exploitation).
Inconvénients
I À tout instant, au plus un thread par processus est en cours d’exécution. Cette
implémentation n’est pas intéressante pour des systèmes multiprocesseurs.
I Si un thread d’un processus se bloque, tout le processus est bloqué. Pour
pallier cet inconvénient, certaines librairies transforment les appels système
bloquants en appels système non bloquants.

Gestion de thread
Thread noyau
Les threads noyau sont directement supportés par le système
d’exploitation qui se charge de leur gestion.
I Ex. Linux ne fait pas de distinction entre les processus et les threads qui sont
communément appelés tâches.
Ordonnacement directement géré par le noyau.
I Il est donc nécessaire de disposer d’une table des threads pour mémoriser les
contextes d’exécution et les informations de chaque thread.
Affectation du CPU fait sur base des threads.
I Un temps CPU est alloué à chaque thread

Gestion de thread
Thread noyau
Avantages
I Si un thread d’un processus est bloqué, un autre thread du processus peut
être élu par le noyau.
I Un processus peut ajuster les niveaux de priorité de ses threads. Par exemple,
un processus peut améliorer son interactivité en assignant : une forte priorité
à un thread qui traite les requêtes des utilisateurs et une plus faible priorité
aux autres.
I Différents threads peuvent être répartis sur plusieurs cœurs, Cette
implémentation est plus intéressante pour les systèmes multiprocesseurs.
Inconvénients
I Performance (gestion plus coûteuse)
I Le changement de contexte nécessite de passer par le noyau
I Les programmes utilisant les threads noyau sont moins portables que ceux qui
utilisent des threads utilisateur.

Gestion de thread
Modèle de multi-threading : Plusieurs-vers-un
Plusieurs threads utilisateurs liés au seul thread noyau

La gestion des threads se fait au niveau utilisateur
I L’application bloque si un seul thread bloque
I Pas d’exécution parallèle sur multi-cœur (un seul thread à la fois peut accéder
au noyau)
Exemples :
I Solaris Green Threads
I GNU Portable Threads

Gestion de thread
Modèle de multi-threading : Un-vers-un
Chaque thread utilisateur est lié à un thread noyau

La gestion des threads est faite par le noyau
I Créer un thread devient couteux car il faut un thread noyau
I Limitation du nombre de threads comme sur Linux et Windows
Exemples :
I Windows NT/2000/XP
I OS/2
I Linux
I Solaris 9 et suivants

Gestion de thread
Modèle de multi-threading : Plusieurs-vers-plusieurs

Multiplexage des threads utilisateurs sur les threads noyaux
I Un ensemble de threads d’un même processus peut être associés à un
ensemble de threads noyau
Combinent les avantages des deux approches:
I Existence de threads noyau (qui sont gérés par le noyau)
I Et des threads utilisateur sont multiplexées dessus
Permet une meilleure concurrence
I Plusieurs threads en même temps, moins de blocage
Exemples :
I Solaris avant version 9
I Windows NT/2000 (avec
ThreadFiber )
Inconvénient : mise en œuvre plus
complexe

Gestion de thread
Modèle à deux niveaux : Threads hybrides
Combinaison du plusieurs-vers-plusieurs et un-vers-un

I Ex. IRIX, HP-UX, Tru64 UNIX, Solaris 8 et avant
Exemples : Threads Solaris

Gestion de thread
Librairie de thread
Une librairie de thread fournit une API pour la création et la gestion de

threads
Deux approches d’implémentation
I Intégralement dans l’espace utilisateur, sans support kernel
Utilisation par invocation de fonctions
I Librairie dans l’espace noyau
Utilisation par appels systèmes
Trois librairies courantes principales
I POSIX Pthreads
I Windows
I Java

Gestion de thread
Pthread
(POSIX Thread)

Gestion de thread
Introduction
De nombreux systèmes d’exploitation permettent aujourd’hui la

programmation multi-threads.
La bibliothèque Pthread (POSIX thread), conforme à la norme IEEE
POSIX4.a, s’est imposée. Elle fournit des primitives pour gérer les threads.
Ces primitives sont similaires à celles fournies par diverses autres
bibliothèques (Solaris, Windows) ou langages (Java).
Les pthreads sont indépendants de leur implémentation (threads utilisateur,
noyau et hybride)

Gestion de thread
La norme POSIX
La norme POSIX est l’acronyme Portable Operating System Interface for
uniX ou interface portable pour les systèmes d’exploitation.
Elle a initialement été mise en place pour les systèmes de type UNIX mais
d’autres systèmes d’exploitation comme Linux, macOS, Solaris et
Windows sont aujourd’hui conformes à POSIX.

Gestion de thread
La norme POSIX
La norme POSIX définit une interface de programmation standard en

langage C (API) pour les threads
I Un ensemble de structure de données et de fonctions mise à disposition par le
système d’exploitation
Cette norme a été développée par l’IEEE (Institute of Electrical and
Electronic Engineering ) et standardisée par l’ANSI (American National
Standards Institute) et l’ISO (International Standards Organisation).
Le but de POSIX est d’obtenir la portabilité des logiciels au niveau de leur
code source.
Un programme qui est destiné à un système d’exploitation qui respecte
POSIX doit pouvoir être adapté à moindre frais sous n’importe quel autre
système POSIX.
En théorie, le portage d’une application d’un système POSIX vers un autre
doit se résumer à une compilation des sources du programme.

Gestion de thread
Les sous-standards POSIX
Le standard POSIX est divisé en plusieurs sous-standards :
POSIX.1 (IEEE Std 1003.1-1990), Interface de base d’accès au système :
I gestion des processus (fork, exec, kill ...)

I fichiers et terminaux (open, fopen , fgetc, dup, fcntl, mkdir ...)
I information runtime (getpid, cuerid, uname ...)
I signaux de base (signal, raise, sigaction ... )
I gestion mémoire (malloc, memcpy, free ...)
I gestion du temps (time, clock ...)
I exécution (setjmp, longjmp ...)
I communication (pipe, mkfifo, setbuf stream, ...)

Gestion de thread
POSIX.4 (IEEE Std 1003.1b-1993), extension pour le temps réel :
I l’ordonnancement
I les signaux en temps réel
I les horloges et les timers
I les sémaphores
I le passage de messages
I la mémoire partagée
I les entrées-sorties synchrones et asynchrones
I les outils de verrouillage de la mémoire

Gestion de thread
POSIX.4a (IEEE Std 1003.1c-1995), extension sur les threads :
I la création, le contrôle et la suppression des threads

I l’ordonnancement des threads
I la synchronisation des threads
I l’interception des signaux (Signal Handling)
POSIX.4b (IEEE Std 1003.1d-1995), plus d’extension sur le temps réel :
I Gestion des interruptions;

Gestion de thread
Les bases de Pthread
Un programme C utilisant la bibliothèque pthread doit disposer de l’entête

suivant :
include <pthread.h>
Les variables pthread sont des objets de type:

I pthread_t : identifiant d’un thread
I pthread_attr_t : attribut d’un thread
I pthread_mutex_t : mutex (exclusion mutuelle)
I pthread_mutexattr_t : attribut d’un mutex
I pthread_cond_t : variable de condition
I pthread_condattr_t : attribut d’une variable de condition
I pthread_key_t : clé pour accès à une donnée globale réservée
I pthread_once_t : initialisation unique

Gestion de thread
Les bases de Pthread
Une fonction pthread renvoie 0 en cas de succès et valeur différente de

NULL en cas d’échec.
En général, le nom de la fonction dépend du type de l’objet auquel elle
s’applique.
I Enlever le _t du type de l’objet
I Ajouter un suffixe précisant le rôle de la fonction. Exemple:
I _init : initialiser un objet.
I _destroy: détruire un objet.
I _create : créer un objet.
I _getattr : obtenir l’attribut attr des attributs d’un objet.
I _setattr : modifier l’attribut attr des attributs d’un objet.
Exemples :
I pthread_create : crée un thread (objet pthread_t)
I pthread_mutex_init : initialise un objet du type mutex

Gestion de thread
Gestion des threads : Définition
Un pthread :
est identifié par un identificateur unique TID (Thread Identifier).
exécute une fonction passée en paramètre lors de sa création.
possède des attributs.
peut se terminer (pthread_exit) ou être annulé par un autre thread
(pthread_cancel).
peut attendre la fin d’un autre thread (pthread_join)

Gestion de thread
Gestion des threads : Attributs
Les attributs d’un thread indiquent ses différentes propriétés:

I son type (noyau ou utilisateur),
I sa stratégie d’ordonnancement,
I sa priorité,
I tâche joignable/détachable,
I la taille de la pile,
I etc.
Ils sont passés au moment de la création de thread:
I Paramètre du type pthread_attr_t
Ils peuvent être initialisés avec les valeurs par défaut :
int pthread_attr_init (pthread_attr_t *attrib) ;

Gestion de thread
Gestion des threads : Attributs

Chaque attribut possède un nom utilisé pour construire les noms de deux
types fonctions :
I pthread_attr_getnom (pthread_attr_t *attr, ...): Extraire la valeur
de l’attribut nom de la variable attr
I pthread_attr_setnom (pthread_attr_t *attr, ...) : Modifier la valeur
de l’attribut nom de la variable attr
Noms des attributs sont:
I scope (int): thread natif (noyau) ou pas
I stackaddr (void *): adresse de la pile
I stacksize (size_t): taille de la pile
I detachstate (int): thread joignable ou détaché
I schedpolicy (int): type d’ordonnancement
I schedparam (sched_param *): paramètres pour l’ordonnanceur
I inheritsched (int): ordonnancement hérité ou pas.
Exemple: Obtenir/modifier la taille de la pile d’un thread
I int pthread_attr_getstacksize (const pthread_attr_t *attributs,
size_t *taille);
I int pthread_attr_setstacksize (const pthread_attr_t *attributs,
size_t taille);
Gestion de thread
Gestion des threads : Création
La création d’un thread est réalisée avec la fonction suivante :

int pthread_create(pthread_t *thd_id, pthread_attr_t *attr,
void* (*start_routine)(void*), void *arg);
I thd_id : pointeur de type pthread_t contenant l’identificateur du thread créé
I attr : si NULL, le thread est crée par les attributs par défaut
I start_routine : le nom de la fonction C qui sera exécutée par le thread créé
I arg : pointeur correspond aux variables passées en paramètre à la fonction
start_routine. Il vaut NULL si aucun paramètre n’est passé à la fonction
Comme valeur de retour, la fonction pthread_create renvoie 0 si tout s’est
bien passé et un nombre négatif sinon.

Gestion de thread

Thread principal versus Threads annexes
La création d’un processus donne lieu à la création du thread principal

(thread main).
I Un retour à la fonction main entraîne la terminaison du processus et par
conséquent la terminaison de tous ses threads.
Un thread créé par la primitive pthread_create dans la fonction main est
appelée un thread annexe.
I Un retour de la fonction correspondante au thread annexe ou un appel à la
fonction pthread_exit entraînent la terminaison du thread annexe
aucun effet sur l’existence du processus ou des autres threads.
I L’appel à exit par un thread annexe provoque la terminaison du processus et
de tous les autres threads.

Gestion de thread

Thread principal versus Threads annexes
Logigramme

Gestion de thread
Exemple 1
# include < stdio .h >
# include < pthread .h >
void * fct ( void * arg )
{
printf ( " Je suis le thread % lu \ n " , pthread_self () ) ;
printf ( " J ai recu l ’ argument % s \ n " , ( char *) arg ) ;
}
int main ()
{
pthread_t thd ;
printf ( " Le processus % d lance un thread \ n " , getpid () ) ;
if ( p thread_create (& thd , NULL , fct , " BONJOUR " ) )
perror ( " pthread_create \ n " ) ;
else
pthread_join ( thd , NULL ) ;
return 0;
}

Gestion de thread
Gestion des threads : TID
Obtention de l’identificateur du thread courant (TID) :

pthread_t pthread_self (void);
Comparaison entre deux identificateurs de threads
pthread_t pthread_equal(pthread_t t1, pthread_t t2);
I Test d’égalité : renvoie une valeur non nulle si t1 et t2 identifient le même
thread.

Gestion de thread
Gestion des threads : Terminaison
La terminaison d’un thread est réalisée avec la fonction suivante :

void pthread_exit(void *status);
I statut sert à récupérer la valeur de retour et l’état de terminaison.
I Elle est accessible aux autres threads du même processus par l’intermédiaire
de la fonction pthread_join.

Gestion de thread

Attendre la fin d’un thread
Lorsqu’un thread crée un autre thread, s’il ne lui est pas explicitement
indiqué d’attendre la fin d’exécution du thread fils, alors à sa terminaison il
forcera l’arrêt du thread fils.
Pour éviter cela, on utilise la fonction pthread_join:
void pthread_join(pthread_t thd_id, void**statut)
I thd_id : représente l’identificateur du thread que le thread créateur doit
attendre.
I statut sert à récupérer la valeur de retour et l’état de terminaison. Il vaut
NULL si le thread ne renvoie aucune valeur.
I Le thread thd_id doit appartenir au même processus que le thread appelant.
I Si le thread thd_id n’est pas encore terminée, le thread appelant sera bloqué
jusqu’à ce que le thread thd_id se termine.
I Si le thread thd_id est déjà terminée, le thread appelant n’est pas bloquée.
I Le thread thd_id doit être joignable.
I Un seul thread réussit l’appel.
I Les ressources de thread sont alors libérées.

Gestion de thread

Exemple 2 :

Gestion de thread

Exemple 2
int main ()
{
int i ;
pthread_t thA , thB ;
printf ( " Creation du thread A \ n " ) ;
pthr ead_create (& thA , NULL , threadA , NULL ) ;
printf ( " Creation du thread B \ n " ) ;
pthr ead_create (& thB , NULL , threadB , NULL ) ;
usleep (1000000) ;
// attendre que les threads aient termine
printf ( " Le thread principal attend que les autres se terminent \ n " ) ;
pthread_join ( thA , NULL ) ;
pthread_join ( thB , NULL ) ;
exit (0) ;
}

Gestion de thread

Exemple 2 (Cont...)
void * threadC ( void * inutilise )
void afficher ( int n , char
{
lettre )
afficher (150 , ’C ’ ) ;
{
printf ( " \ n Fin du thread C \ n " ) ;
int j ;
pthread_exit ( NULL ) ;
for ( j =1; j < n ; j ++)
}
{
usleep (1000000) ;
void * threadB ( void * inutilise )
printf ( " % c " , lettre ) ;
{
}
pthread_t thC ;
}
printf ( " Creation du thread C \ n " ) ;
pth read_c reate (& thC , NULL , threadC , NULL ) ;
void * threadA ( void * inutilise )
afficher (100 , ’B ’ ) ;
{
printf ( " \ n Le thread B attend la fin du
afficher (100 , ’A ’ ) ;
thread C \ n " ) ;
printf ( " \ n Fin du thread
pthread_join ( thC , NULL ) ;
A\n");
printf ( " \ n Fin du thread B \ n " ) ;
}
}

Gestion de thread

Exemple 2 : Résultats d’exécution

Gestion de thread

Forcer la non-attente d’un thread
Il peut arriver que dans une application multitâche, on n’ait pas besoin que le
processus (le thread principal) attende la fin d’exécution d’un thread annexe
avant de se terminer.
Pour cela, on force le thread annexe à être détaché de son processus.
I Lors de la création :
pthread_attr_t attr ;
p t hre ad_ att r_ ini t (& attr ) ;
p t h r e a d _ a t t r _ s e t d e t a c h s t a t e (& attr , P T H R E A D _ C R E A T E _ D E T A C H E D ) ;
pthread_create ( tid , & attr , func , NULL ) ;
I Par appel à la fonction :
int pthread_detach ( pthread_t thd_id ) ;

Gestion de thread

Thread joignable vs. détaché
Thread Joignable Détaché

Valeur de l’attribut PTHREAD_CREATE_JOINABLE
PTHREAD_CREATE_DETACHED
detachstate (int) (par défaut)
les valeurs de son identité
et de retour sont conservées
Lorsque le thread jusqu’à ce qu’un autre thread Aucun autre thread ne peut
se termine (suite à un en prenne connaissance les récupérer et les ressources
appel pthread_exit) (appel à pthread_join). sont libérées.
Les ressources sont ensuite
libérées.

Gestion de thread
Gestion des threads : Annulation
L’annulation d’un thread est réalisée avec la fonction suivante :

int pthread_cancel(pthread_t thd_id);
I Demande au thread thd_id de se terminer, pas forcément pris en compte
immédiatement).
Cette requête n’est prise en compte par thd_id que lorsque ce dernier arrive
sur une primitive bloquante (pause, pthread_cond_wait,...), ou
explicitement via l’appel à pthread_testcancel :
void pthread_testcancel(void);
I Le thread courant teste s’il a reçu une demande d’annulation
I Le thread se termine à ce point si le test est positif
I Le retour du thread vaut PTHREAD_CANCELED

Gestion de thread
Changer l‘état d’annulation d’un thread

int pthread_setcancelstate(int state, int * oldState);
Cette fonction change l‘état d’annulation du thread courant à state

I PTHREAD_CANCEL_ENABLE: annulations autorisées (par défaut)
I PTHREAD_CANCEL_DISABLE: annulations ignorées
Indique l’ancien état si oldState est non nul
Retour : 0 si ok, non nul si erreur

Gestion de thread
Change le type d’annulation d’un thread

int pthread_setcanceltype(int type,int * oldType);
Cette fonction change le type d’annulation du thread courant à type

I PTHREAD_CANCEL_DEFERRED : annulation prise en compte aux points
d’annulation (par défaut)
I PTHREAD_CANCEL_ASYNCHRONOUS : annulation prise en compte immédiatement
(dangereux !)
Indique l’ancien type si oldType est non nul
Retour : 0 si ok, non nul si erreur

Main 3

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Main 3

Transféré par

Droits d'auteur :

Formats disponibles

Gestion de thread

Pthread (POSIX Thread)

Pr. Abdessamad EL BOUSHAKI

Pr. Abdessamad EL BOUSHAKI (FST Marrakech) Système d’exploitation 1/54

Pr. Abdessamad EL BOUSHAKI (FST Marrakech) Système d’exploitation 2/54

Nécessite des mécanismes de communications complexes (mis en place par

Commutation de contexte coûteuse

Pr. Abdessamad EL BOUSHAKI (FST Marrakech) Système d’exploitation 3/54

Pr. Abdessamad EL BOUSHAKI (FST Marrakech) Système d’exploitation 4/54

Un thread possède une série d’informations propres à lui

Un thread partage avec les threads du même processus

Mécanisme simple de passage entre threads

Pr. Abdessamad EL BOUSHAKI (FST Marrakech) Système d’exploitation 5/54

Utilisation des threads

Exemple d’utilisation des threads :

Distinction travail avant-plan/arrière-plan, asynchrone

Structure modulaire de programme

Fonction à exécuter plusieurs fois en parallèle

Pr. Abdessamad EL BOUSHAKI (FST Marrakech) Système d’exploitation 6/54

Processus mono- et multi-threads

Pr. Abdessamad EL BOUSHAKI (FST Marrakech) Système d’exploitation 7/54

Processus mono- et multi-threads

Pr. Abdessamad EL BOUSHAKI (FST Marrakech) Système d’exploitation 8/54

Une application est implémentée comme un processus

Peut exploiter les CPU multi-cœurs

Les threads évitent de devoir créer un nouveau processus

Pr. Abdessamad EL BOUSHAKI (FST Marrakech) Système d’exploitation 9/54

Parmi les avantages du multi-threading :

Pr. Abdessamad EL BOUSHAKI (FST Marrakech) Système d’exploitation 10/54

possibles combinaisons "Processus - threads"

Pr. Abdessamad EL BOUSHAKI (FST Marrakech) Système d’exploitation 11/54

Table des threads

Lorsqu’un processus est créé, un seul thread (qui exécute le programme

Ce thread (appelé le thread principal) peut en créer d’autres threads

Chaque entrée de cette table contient une structure de données particulière

Pr. Abdessamad EL BOUSHAKI (FST Marrakech) Système d’exploitation 12/54

Bloc de contrôle de thread : TCB

Comme le PCB, le TCB contient des informations nécessaire à :

L’exécution du thread appelé le contexte d’un thread. Ce contexte permet

Informations nécessaires à la gestion du thread.

Pr. Abdessamad EL BOUSHAKI (FST Marrakech) Système d’exploitation 13/54

TCB : Contexte du thread

Le processus est vu comme étant un

Pr. Abdessamad EL BOUSHAKI (FST Marrakech) Système d’exploitation 14/54

TCB : Informations de gestion

Le TCB contient des informations du thread permettant l’identification et la

Pr. Abdessamad EL BOUSHAKI (FST Marrakech) Système d’exploitation 15/54

États d’un thread

Pr. Abdessamad EL BOUSHAKI (FST Marrakech) Système d’exploitation 16/54

Le support pour les threads peut être fourni à deux niveaux

Pr. Abdessamad EL BOUSHAKI (FST Marrakech) Système d’exploitation 17/54

Pr. Abdessamad EL BOUSHAKI (FST Marrakech) Système d’exploitation 18/54

Pr. Abdessamad EL BOUSHAKI (FST Marrakech) Système d’exploitation 19/54

Pr. Abdessamad EL BOUSHAKI (FST Marrakech) Système d’exploitation 20/54

Pr. Abdessamad EL BOUSHAKI (FST Marrakech) Système d’exploitation 21/54

Modèle de multi-threading : Plusieurs-vers-un

Plusieurs threads utilisateurs liés au seul thread noyau

Pr. Abdessamad EL BOUSHAKI (FST Marrakech) Système d’exploitation 22/54

Modèle de multi-threading : Un-vers-un

Chaque thread utilisateur est lié à un thread noyau

Pr. Abdessamad EL BOUSHAKI (FST Marrakech) Système d’exploitation 23/54

Modèle de multi-threading : Plusieurs-vers-plusieurs

Pr. Abdessamad EL BOUSHAKI (FST Marrakech) Système d’exploitation 24/54