Université de Sousse
Motivations des processus légers
Ecole Supérieure des Sciences
et des Technologies de Hammam Sousse
Cours : Systèmes d’exploitation II
Chapitre 2 :
Introduction aux threads
Cours LI 1
Dr. Olfa FAKHFAKH
fakhfakh.olfa@essths.u-sousse.tn
A.U. 2022-2023
Motivations des processus légers
● Il s'ensuit trois problèmes des machines parallèles:
▶Problème de performance à la création du
processus, puisque l'allocation et la recopie du PCB
et de la zone mémoire sont des mécanismes coûteux,
▶Problème de performance à la commutation (dans
l'unité centrale) d'un processus à l'autre, puisque les
processus travaillent sur des zones de mémoire
différentes qu'il faut recharger.
▶Problème de communication entre les processus,
qui ont des variables séparées (... d'où la nécessité
d'utiliser des segments de mémoire partagée pour
mettre des données en commun).
3 4
2/6/2023 Dr. Olfa FAKHFAKH
● Sur une machine parallèle (ayant plusieurs processeurs), on
peut accélérer l'exécution d'un programme en exécutant
certaines parties en parallèle sur les différents processeurs.
● En UNIX, cela peut être fait en créant (avec un fork) un
nouveau processus pour chaque partie à paralléliser.
● Dans ce cas, les processus se communiquent leurs résultats,
et se synchronisent, à l'aide des IPC, segments de mémoire
partagée et sémaphores. Cependant, cette façon de
paralléliser les tâches s'avère assez « lourde ».
● En effet, chaque nouveau processus possède son propre
PCB et sa propre zone de mémoire.
2
2/6/2023 Dr. Olfa FAKHFAKH
Processus léger (thread)
● Un thread est une partie des instructions du processus en
cours d'exécution.
● Chaque processus peut s’exécuter comme le système
d'exploitation en lançant des sous-tâches internes au
processus.
● Ces sous-tâches sont nommées, « flot d’exécution »,
«processus légers », ou Threads.
● Le processus est considéré comme étant un ensemble de
ressources (périphériques, segments de données, de fichiers,
etc.) que les Threads partagent.
2/6/2023 Dr. Olfa FAKHFAKH
 Usage des Threads : Word processor Processus vs Thread

● Un processus peut contenir un ou plusieurs thread

(applications dites multi-threadées) s'exécutant en quasi-
simultanéité ou simultanément sur les processeurs multi-
coeurs.

● À la différence des processus, les threads partagent le

même espace mémoire protégé, les mêmes ressources et
le même espace mémoire.

● Chaque thread a :
● Un thread pour interagir avec l’utilisateur, – un identificateur unique
● Un thread pour reformater en arrière plan, – une pile d'exécution
● Un thread pour sauvegarder périodiquement le document – des registres (un compteur ordinal)
5
– un état… 6
2/6/2023 Dr. Olfa FAKHFAKH 2/6/2023 Dr. Olfa FAKHFAKH

Processus vs Thread Avantages des threads

● Un processus = activité utilisant certaines ressources.
● Conservons le principe de mise en commun des ressources, mais
divisons l’activité en entités d’exécution, des threads.
● À un thread correspond des ressources définies dans un processus.
● Réactivité : le processus peut continuer à s’exécuter même si
certaines de ses parties sont bloquées,
● Partage de ressources (facilite la coopération, améliore la
performance),

● Économie d’espace mémoire et de temps. Il faut moins de

temps pour :
▶ créer, terminer un thread (sous Solaris, la création d’un
processus est 30 fois plus lente que celle d’un thread),
● Exemple : ▶ “switcher” entre deux threads d’un même processus.
● La JVM (Java Virtual Machine) est un exemple de programme multi-threadé
● Communication simple entre les Threads
● Un des threads de la JVM est le Garbage Collector (ramasse-miettes) qui
récupère automatiquement l’espace mémoire occupé par un objet non
référencé.
7 8
2/6/2023 Dr. Olfa FAKHFAKH 2/6/2023 Dr. Olfa FAKHFAKH
 La multiprogrammation Threads utilisateurs et threads noyau
● Le multithread a été introduit dans les systèmes pour permettre
la mise en œuvre du parallélisme à l'intérieur des processus. ● Threads utilisateur
● La multiprogrammation, réalisée en utilisant des processus légers ▶gérés par une bibliothèque utilisateur
ou threads, fournit un parallélisme plus fin et permet de détailler
l'exécution d'un processus. par exemple pthread sous Linux ou thread dans
Solaris

▶Le changement de contexte est rapide.

▶Ils sont portables sur différentes plateformes

● Threads noyau
● Le multithreading permet l’exécution simultanée ou en pseudo- ▶Ils sont gérés par le noyau du S.E.
parallèle de plusieurs parties d’un même processus. ▶Le changement de contexte est lent
9 10
2/6/2023 Dr. Olfa FAKHFAKH 2/6/2023 Dr. Olfa FAKHFAKH

Services POSIX pour la gestion des threads Création de threads

● La bibliothèque pthread définit un ensemble de structure de int pthread_create (

données et de fonctions C implantant des threads
pthread_t *thread ,
● Pour UNIX il existe la norme POSIX (ISO 9945-1) qui définit pthread_attr_t *attr,
des appels standards.
void *nomfonction,
● Cette norme propose la spécification d'un ensemble de void *arg );
fonctions permettant de solliciter les services de base d'un
système d'exploitation. ● thread : pour récupérer l'identité du thread créé
● attr : attributs du thread, permettent de spécifier la taille de la
pile, la priorité, la politique de planification… par défaut NULL
● fonction : fonction à exécuter en parallèle par le thread créé
● arg : arguments de la fonction
11 12
2/6/2023 Dr. Olfa FAKHFAKH 2/6/2023 Dr. Olfa FAKHFAKH
 Création de threads Identité d’un thread

● La primitive pthread_create() demande le lancement d'un nouveau

processus léger, et retourne 0 en cas de succès.
# include < pthread.h>
● En cas d’échec, un message d’erreur est retourné (e.g. nombre
maximum de threads PTHREAD_THREADS_MAX déjà atteint, pas pthread_t pthread_self ( void ) ;
assez de ressources etc).

● Ce processus léger s'exécutera de façon concurrente avec le ● pthread_self() retourne l’identificateur du thread
processus appelant : si la machine a plusieurs processeurs, alors
chaque processus léger pourra s'exécuter sur un processeur courant dans le processus courant
différent ; sinon le parallélisme sera simulé...

● *thread, contient l'identifiant du nouveau processus léger.

● Cet identifiant peut être connu en appelant la fonction pthread
self().

13 14
2/6/2023 Dr. Olfa FAKHFAKH 2/6/2023 Dr. Olfa FAKHFAKH

Egalité entre threads Suspension des threads

● Attente la fin d’un thread.

# include < pthread.h> int pthread_join(

| int pthread_equal(pthread_t t1, pthread_t t2);
● pthread_equal(t1,t2) retourne 0 si les deux identités
transmises en argument sont identiques et une valeur non nulle
sinon.
pthread_t thid,
void **valeur_de_retour);
● pthread_join() suspend l'exécution d'un thread courant (qui l’invoque)
jusqu'à ce que termine le thread avec l'identificateur thid.
● valeur_de_retour : récupère l'état de terminaison du thread thid
● pthread_join revoie 0 en cas de succès

 Appel bloquant jusqu‘à ce que le thread thid termine.

15 16
2/6/2023 Dr. Olfa FAKHFAKH 2/6/2023 Dr. Olfa FAKHFAKH
 Terminaison des threads Exemple 1
● Création de 2 threads : un qui affiche « Hello », et l'autre qui affiche « World
»
void* ma_proc( void *ptr ){
void pthread_exit( char *message;
message = (char *) ptr;
void *valeur_de_retour);
printf("%s ", message);
}

● pthread_exit() permet de terminer l’exécution du thread qui l’a

appelé main(){
pthread_t thread1, thread2; // identifiants des threads
● cette primitive retourne l'état de terminaison dans l’adresse char *m1 = "Hello";
valeur_de_retour char *m2 = "World";
pthread_create( &thread1, NULL, ma_proc, (void*) m1);
pthread_create( &thread2, NULL, ma_proc, (void*) m2);
exit(0);
}
17 18
2/6/2023 Dr. Olfa FAKHFAKH 2/6/2023 Dr. Olfa FAKHFAKH

Suite Exemple

● Les deux threads sont exécutes de façon "concurrente".

● Un premier problème est que l'on n'a aucune certitude sur
l'ordre dans lequel ces deux threads s'exécutent, de sorte que
"World" peut très bien s'afficher avant "Hello". On verra d'ici
peu comment résoudre les problèmes de synchronisation
entre processus à l'aide des sémaphores et variables de
condition.

● Le deuxième problème, probablement plus grave, est que

lorsque le processus appelant exécute son instruction exit(0),
les threads qu'il a crées sont détruits, même s'ils n'ont pas ni
de s'exécuter (ce qui est fort probable). Il faut donc que le
processus créant les threads attende la fin de l'exécution des
threads avant de mourir.
19
2/6/2023 Dr. Olfa FAKHFAKH