Projet SE PDF

RÉPUBLIQUE ALGÉRIENNE DÉMOCRATIQUE ET POPULAIRE
Ministère de l’Enseignement Supérieur et de la Recherche Scientifique

Université d’alger 1 -Ben Youcef BenKheda
Faculté des sciences
Departement informatique
Thème : les threads
Module : Système d’exploitation
En : 2ème année licence informatique
Enseignant :
Mr.Mahseur.
Réalisée par :
-BENZINE Imene A3
-SAADI Imene A3
-AIT ALI BELKACEM Sonia A3
Année universitaire :2023-2022.

RÉSUMÉ
un thread est une unité d’exécution dans un processus qui peut être exécuté simultané-
ment avec d’autres threads au sein du même processus. Les threads permettent d’effectuer
plusieurs tâches en même temps, en partageant les ressources du système telles que le pro-
cesseur et la mémoire.
Les threads sont couramment utilisés dans les applications qui nécessitent des opérations
simultanées, telles que les applications réseaux , les interfaces utilisateur graphiques, les si-
mulations, les jeux vidéos , les logiciels de traitement d’images et de vidéos, etc.
Ils peuvent être créés et contrôlés par le système d’exploitation ou par la bibliothèque
de programmation utilisée par l’application. Les développeurs peuvent utiliser des threads
pour améliorer l’efficacité et les performances de l’application, mais ils doivent faire preuve
de prudencelors de l’utilisation de threads pour éviter les problèmes de concurrence, tels que
les conditions de concurrence et les deadlocks.
En resumé, les threads sont une méthode courante pour exécuter des tâches simultanées
dans les applications informatiques en partageant les ressources du système. Bien que les
threads puissent améliorer l’efficacité et les performances de l’application, ils peuvent égale-
ment causer des problèmes de concurrence, qui nécessitent une planification et une gestion
appropriées pour qu’elle soit évitée.
TABLE DES MATIÈRES
1 Généralités sur les threads 3

1.1 La définition de threads : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2 Des exemples sur les threads : . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.3 Les avantages d’un thread : . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.3.1 Réactivité : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.3.2 Partage des ressources : . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.3.3 Économie : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.3.4 Scalabilité (passage à l’échelle) : . . . . . . . . . . . . . . . . . . . . . 8
1.4 La création et l’execution d’un thread : . . . . . . . . . . . . . . . . . . . . . 9
1.4.1 Algorithme de creation d’un thread : . . . . . . . . . . . . . . . . . . 9
1.4.2 Les paramètres de la fonction pthread_create : . . . . . . . . . . . . 10
1.4.3 Exemple : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.4.4 Explication et détails : . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2 Gestion et implémentation de thread 13

2.1 Les modéles de multithreading : . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.1.1 Threads utilisateur : . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.1.2 Thread noyau : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.1.3 Threads hybrides N :M . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.2 Etats d’un thread . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
3 Processus et thread 18
3.1 Communication entre les threads et les processus : . . . . . . . . . . . . . . . 18
3.2 Différence entre processus et thread : . . . . . . . . . . . . . . . . . . . . . . 22
1
TABLE DES FIGURES
1.1 les threads . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.1 Thread utilisateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

2.2 Thread noyau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.3 Thread hybride . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.4 Les états de thread . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
3.1 Pipe (tube) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

3.2 Envoie de message . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
3.3 Partage de mémoire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
3.4 Comparaison entre Thread et Processus . . . . . . . . . . . . . . . . . 23
2
LISTE DES TABLEAUX
2.1 Avantages et inconvenients des threads utilisateur . . . . . . . . . . 14

2.2 Avantages et Inconvenients des threads noyau . . . . . . . . . . . . . 15
3
LISTE DES ALGORITHMES
1 création d’un thread . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

2 "hello world" Pthreads program . . . . . . . . . . . . . . . . . . . . . . . . . 11
4
INTRODUCTION GÉNÉRALE
Le modèle de processus introduit jusqu’à ce point suppose qu’un processus

est un programme qui s’exécute dans un flot d’exécution unique, c’est-à-dire
une tâche unique séquentielle. Un flot d’exécution est appelé : thread d’exé-
cution. Par exemple, si un processus exécute un programme de traitement
de texte,il y a un flot d’instructions unique qui est exécuté. Ce flot unique ne
permet au processus d’exécuter qu’une tâche à la fois.
Toutefois, il est plus intéressant et plus performant de pouvoir exécuter

plusieurs tâches à la fois dans un même processus ou même programme.
Par exemple, il est souhaitable de, simultanément, taper des caractères et
exécuter un programme de correction orthographique à l’intérieur du même
processus, ce qui n’est pas possible avec le modèle simple de processus, consti-
tué d’un seul thread.
Une première solution qui a été utilisée dans les systèmes d’exploitation
est la création de processus fils, qui permet d’exécuter des tâches paral-
lèles. Néanmoins, les processus fils sont des processus indépendants, ne se
partageant aucune ressource. Lorsque des ressources sont communes (comme
par exemple des variables globales communes aux processus fils). le système
doit gérer le partage d’une manière efficace.
Une deuxième alternative introduite actuellement est de permettre à un
1
LISTE DES ALGORITHMES
processus d’avoir plusieurs flots d’exécution multiples : ce processus est alors

dit multithread, càd processus ayant la possibilité d’effectuer plusieurs tâches
au même moment. De nombreux systèmes d’exploitation modernes ont étendu
le concept de processus au concept du multithreading.
2
CHAPITRE 1
GÉNÉRALITÉS SUR LES THREADS
1.1 La définition de threads :
Un thread appelé parfois processus léger est une séquence d’instructions

programmées qui peut être gérée indépendamment par un ordonnanceur, qui
est généralement une partie du système d’exploitation[8].Les threads per-
mettent à plusieurs instances d’un programme de s’exécuter simultanément
au sein du même processeur, partageant une partie de l’état du processus [11].
En première analyse, on peut imaginer les threads comme des processus

partageant les mêmes données statiques et dynamiques.
-Chaque thread dispose personnellement d’une pile et d’un contexte d’exé-

cution contenant les registres du processeur et un compteur d’instruction.
-Les méthodes de communication entre les threads sont alors naturellement
plus simples que les communications entre processus.
-En contre partie, l’accès concurrentiel aux mêmes données nécessite une
synchronisation pour éviter les interférences, ce qui complique certaines por-
tions de code.
Les threads ne sont intéressants que dans les applications assurant plu-
3
CHAPITRE 1. GÉNÉRALITÉS SUR LES THREADS
sieurs tâches en parallèle.

Si chacune des opérations effectuées par un logiciel doit attendre la fin
d’une opération précédente avant de pouvoir démarrer, il est totalement in-
utile d’essayer une approche multithread.
Un thread est l’unité de base de l’utilisation du CPU, il comporte :

• Un identifiant de thread.
• Un program counter (ou compteur ordinal).
• Un ensemble de registres.
• Et une pile.
4
Figure 1.1 – les threads
Il partage avec les autres threads appartenant au même processus :

• La section de code.
• La section de données.
• Et d’autre ressources du système d’exploitation, telles que les fichiers
ouverts et les signaux.
Un processus traditionnel (poids lourd) a un seul thread : si un proces-

sus a plusieurs threads, il peut effectuer plus d’une tâche à la fois.[4]
5
1.2 Des exemples sur les threads :
1. Un navigateur Web peut avoir un thread qui affiche des images ou des
textes, tandis qu’un autre thread récupère des données du réseau.[10]
2. Un traitement de texte peut avoir un thread qui affiche les gra-
phiques, un autre thread pour lire les touches tapées par l’utilisateur
et troisième thread pour effectuer les corrections orthographiques en
arrière-plan.[10]
3. Un serveur Web, recevant plusieurs requêtes de clients pour obtenir
des pages, lance un thread qui attend ces requêtes. Lorsqu’une re-
quête arrive, plutôt que de créer un nouveau processus, il démarre
un autr thread qui s’en occupe.[10]
4. Téléchargement de fichiers en parallèle : lorsque vous téléchargez un
gros fichier depuis Internet, vous pouvez utiliser des threads pour
diviser le téléchargement en plusieurs parties qui sont téléchargées
en parallèle, ce qui accélère le processus de téléchargement.[4]
5. Lecture et écriture de fichiers : si vous avez besoin de lire ou d’écrire
de gros fichiers, vous pouvez utiliser des threads pour accélérer le
processus. Par exemple, vous pouvez lire une partie du fichier en
utilisant un thread tandis qu’un autre thread écrit une autre partie
du fichier.[4]
6. Interface utilisateur : dans une application avec une interface gra-
phique, vous pouvez utiliser des threads pour effectuer des tâches
en arrière-plan afin de ne pas bloquer l’interface utilisateur prin-
cipale. Par exemple, si vous devez effectuer une tâche longue qui
pourrait prendre quelques secondes, vous pouvez l’exécuter dans un
thread distinct pour que l’interface utilisateur reste réactive pendant
l’opération.[4]
7. Calcul intensif : si vous devez effectuer des calculs intensifs dans une
application, vous pouvez utiliser des threads pour les exécuter en
parallèle sur différents processeurs ou cœurs de processeur, ce qui
6
accélère le temps d’exécution.[4]

8. Traitement de données en temps réel : dans une application qui traite
des données en temps réel, vous pouvez utiliser des threads pour
traiter les données en parallèle, ce qui permet de réduire le temps de
traitement et de maintenir une performance en temps réel.[4]
7
1.3 Les avantages d’un thread :
1.3.1 Réactivité :
Rendre une application Multithreadée peut permettre à une partie de

continuer à fonctionner même si une autre partie est bloqué ou effectuer
une opération longue.
1.3.2 Partage des ressources :
Les processus peuvent se partager des ressources grâce à des techniques

telles que la mémoire partagée ou la transmission de messages. Ces
techniques doivent être explicitement implémentées par le program-
meur. Cependant, les threads partagent la mémoire et les ressources
du processus auxquels ils appartiennent par défaut.
1.3.3 Économie :
Alloué de la mémoire et de ressources pour la création des processus

est coûteux. Vu que les threads partagent les ressources du processus
auxquels ils appartiennent, il est plus économique de créer et d’ exécuter
des commutations de contexte.
1.3.4 Scalabilité (passage à l’échelle) :
Les avantages du multithreading peuvent être considérablement aug-

mentés dans une architecture multiprocesseur, où les threads peuvent
s’exécuter en parallèle sur des processeurs différents.[4]
8
1.4 La création et l’execution d’un thread :
La création d’un thread en programmation dépend du langage de pro-

grammation utilisé.
En général, la création d’un thread implique la définition d’une fonc-
tion qui sera exécutée par le thread, puis l’appel d’une fonction de
création de thread fournie par la bibliothèque de threads du langage.
Par exemple :
En C, la bibliothèque « threads.h » fournit une fonction « thrd_create

» pour créer un thread et lui passer des données initiales[9].
En JAVA, la création d’un thread implique la définition d’une classe qui
étend la classe « Thread » ou implémente l’interface « Runnable
», puis l’instanciation de cette classe et l’appel de la méthode « start
» pour démarrer le thread[2][5].
En C++, la bibliothèque standard fournit une classe « std : :thread
» pour créer un thread et lui passer une fonction à exécuter[1].
En général, la création de threads nécessite une gestion rigoureuse des
ressources partagées et de la synchronisation pour éviter les problèmes
tels que les conditions de concurrence.
1.4.1 Algorithme de creation d’un thread :
La routine pthread_create() crée un processus léger qui exécute la

fonction "start_routine" avec l’argument arg et les attributs attr. Les
attributs permettent de spécifier la taille de la pile, la priorité, la poli-
tique de planification, etc.
Il y a plusieurs formes de modification des attributs. La routine pthread_create
fait partie de la librairie Pthreads qui est un API de la norme POSIX.
Avec cette librairie on crée un thread comme suit :
9
Algorithm 1 création d’un thread

1: int pthread_create (pthread_t * thread, pthread_attr_t * attr, void * (*
start_routine) (void *), void * arg) ;
Cette routine crée et lance le thread immédiatement en exécutant la

fonction passée en troisième argument. L’exécution du thread se fait
soit jusqu’à la fin de l’exécution de sa fonction ou bien jusqu’à son an-
nulation. Il est possible d’utiliser une fonction avec plusieurs threads !.
Si la création du thread réussit, la fonction pthread_create retourne 0

(zéro) et l’identifiant du thread nouvellement créé est stocké à l’adresse
fournie en premier argument. En cas d’erreur, la valeur EGAIN est
retournée par la fonction pthread_create() s’il n’y a pas assez de
ressources système pour créer un nouveau thread ou bien si le nombre
maximum de threads définit par la constante PTHREAD_THREADS
_MAX est atteint !
1.4.2 Les paramètres de la fonction pthread_create :
1. Le paramètre *thread est un pointeur de type pthread_t : le type

pthread est un type opaque, sa valeur réelle dépend de l’implémenta-
tion sous Linux il s’agit en générale du typeb unsigned long. Ce type
correspond à l’identifiant du thread créé. Tout comme les processus
Unix,chaque thread a son propre identifiant.
2. Le paramètre *attr_t est un pointeur de type pthread_attr_t : ce
type est lui aussi un type opaque permettant de définir des attributs
spécifiques pour chaque thread. Il faut savoir qu’on peut changer le
comportement de la gestion des threads, exemple ,on peut les régler
pour qu’ils tournent sur un système temps réel . en générale on se
contente des attributs par défaut et cet argument vaut NULL (valeur
10
par défaut).
3. Chaque thread dispose d’une fonction à exécuter ,c’est en même
temps sa raison d’être. Cet argument de la fonction pthread_creat
est un pointeur de fonction, il permet de transmettre un pointeur sur
la fonction que le thread devra exécuter.
4. Le dernier argument représente un argument que l’on peut passer à
la fonction que le thread doit exécuter.
1.4.3 Exemple :
Algorithm 2 "hello world" Pthreads program

1: Begin
2: #include <pthread.h>
3: #include <stdio.h>
4: #include <stdlib.h>
5: #define NUM_THREADS
6: void *PrintHello(void *threadid){
7: long tid ;
8: tid = (long)threadid;
9: printf ("Hello World ! It’s me, thread #%ld !\ntid);
10: pthread_exit(NULL) ;}
11:
13:
12: int main(intargc, char ∗ argv[]){
15:
14: pthread_tthreads[N U M _T HREADS]; int rc ;
17:
16: long t ;
18: for t = 0 to tN U M _T HREADS do
19: printf ("In main : creating thread /
20: rc = pthread_create( threads[t], NULL, PrintHello, (void *)t) ;
21: if (rc) then
22: printf ("ERROR return code from pthread_create() is %d", rc) ;
23: exit(-1) ;
24: end if
25: end for
26: pthread_exit(NULL) ;
27: End.
11
1.4.4 Explication et détails :
La première chose à avoir en tête est que le programme i.e le "main" est
un thread, donc il va s’exécuter parallèlement au thread créé et lancé
par la routine pthread_create().
Ce dernier, comme on l’a vu ci-dessus, a quatre paramètres : Le premier
paramètre est utilisé pour fournir des informations au thread.
Le second est utilisé pour donner des valeurs à quelques attributs du
thread :dans notre cas ce paramètre vaut "NULL" (pointeur sur une
valeur NULL) pour signifier à la routine thread_creat() de se servir
des valeurs par défaut de tous ses paramètres.
Le troisième paramètre est le nom de la fonction qui sera exécutée par
le thread et le quatrième paramètre est un argument de la fonction exé-
cutée par le thread.
Une fois compilée et exécutée ce programme donne les résultats sui-
vants :[1]
In main : creating thread 0

Hello World ! It’s me, thread 0 !
Hello World ! It’s me, thread #1 !
12
CHAPITRE 2
GESTION ET IMPLÉMENTATION DE THREAD
2.1 Les modéles de multithreading :
L’implémentation des threads varie considérablement d’une plateforme

à une autre .On distingue trois modéles :
— Plusieurs-à-un :les threads sont gérés au niveau utilisateur(threads

utilisateur).
— Un-à-un :les threads sont gérés au niveau du noyau(threads noyau).
— Plusieurs à plusieurs :les threads sont gérés à deux niveau(threads
hybrides).
2.1.1 Threads utilisateur :
L’implémentation des threads en espace utilisateur implique que le par-

tage des ressources de traitement se fait entièrement en espace utilisa-
teur et que le noyau n’a aucune connaissance de la présence de threads
dans les processus.[6]
Chaque processus garde trace des informations sur ses threads,en uti-
lisant une table de threads propre à lui.Cette table est modifiée par le
systéme au fur et à mesure de l’exécution du thread et au changement
d’état du thread.Le thread utilisateur est présenter dans la figure 2.1
13
CHAPITRE 2. GESTION ET IMPLÉMENTATION DE THREAD
Avantages Inconvenients
1-Peut être implementé dans un systéme 1-Ils ne peuvent pas être exécutés en paral-
d’exploitation qui ne supporte pas les léle sur des processeurs differents,car ils sont
threads. exécutés dans le même processus.
2-Creation,basculation,synchronisation les 2-Si un thread se bloque,alors tout le proces-
threads sont trés rapides,car elles sont faites sus est bloquée.
sans l’intervention du noyau.
3-Chaque processus peut avoir son propre or- 3-Ils ne peuvent pas beneficier des avantages
donnancement. des systémes des multiprocessus ou de mul-
tithreading, telque la distribution et l’équili-
brage de charge.
Table 2.1 – Avantages et inconvenients des threads utilisateur
Figure 2.1 – Thread utilisateur
le tableau ci-dessus 2.1 montre : Les avantages et les inconvenients des

threads utilisateur.
2.1.2 Thread noyau :
L’implémentation des threads en espace noyau implique que le systéme

d’exploitation gère les threads,ce existe pour chaque thread à l’interieur
des processus.Le systéme d’exploitation utilise une table des threads
14
Avantages Inconvenients
1- Les threads noyau sont plus efficaces que 1-La gestion(creation,attente,synchronisation)des
les threads utilisateurs en ce qui concerne les threads nécessite des appels systémes.
operations de bas niveau,tellesque les péré-
phiriques l’entrée/sortie,etc.
2-Les threads noyau peuvent accéder à des 2-Les threads noyau ont un accès direct aux res-
ressources materielles ce qui leur permet d’ef- sources matérielles ce qui peut poser des pro-
fectuer des tâches qui ne peuvent être reali- blémes de sécurité.
sées que par le noyau.
3-Le processus n’est bloqué si l’un de ses 3-Les erreurs de programmation dans les threads
threads est bloqué. noyau peuvent entraîner des plantages du SE.
Table 2.2 – Avantages et Inconvenients des threads noyau
lancés, où à chaque création d’un nouveau thread, une nouvelle entrée

et créé dans cette table et est associée au nouveau thread.
Le tableau ci-dessus 2.2 montre : Les avantages et les inconvenients des
threads noyau .[6]
Figure 2.2 – Thread noyau
2.1.3 Threads hybrides N :M
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ésa-
vantages de chacun. Ils sont plus difficiles à implanter puisqu’ils néces-
sitent du code usager et noyau.[6]le thread hybride est présenter dans
la figure 2.3
15
Figure 2.3 – Thread hybride
2.2 Etats d’un thread
Selon la bibliothéque utilisée pour la création de threads, plusieurs états

sont possibles pour un thread, [10]de la même maniére q’un processus
passe par plusieurs états durant sa vie.
Par exemple,un thread JAVA peut être dans l’un des quatre états pos-
sibles :
— Nouveau :lorqu’il est créé(par l’instruction new).
— Exécutable :lorsqu’il est en exécution,le thread[6] lui est alloué de
l’espace mémoire par la méthode start(),puis lancé par la mé-
thode run().
— Bloqué :s’il effectue une instruction qui bloque , comme une de-
mande d’E/S, ou bien une demande de suspension(en invoquant la
méthode sleep()).,ou encore une demande de suspension pour être
16
Figure 2.4 – Les états de thread
endormi(en invoquant la méthode suspend()).

— Mort :si sa méthode run().se termine ,ou la méthode stop().est
appelée.[10]
La figure ci-dessus montre l’état de thread2.4
17
CHAPITRE 3
PROCESSUS ET THREAD
3.1 Communication entre les threads et les pro-

cessus :
Lorsqu’un programme a été décomposé en plusieurs threads, ceux-

ci ne sont en général pas complètement indépendants et ils doivent
communiquer entre eux.
Cette communication entre les threads et les processus est une partie
importante de la programmation concurrente et parallèle. Les threads
et les processus peuvent interagir les uns avec les autres pour coordon-
ner leurs activités et échanger des données. Cette communication est
essentiellement nécessaire pour coordonner leurs activités et partager
des données pour accomplir une tâche commune. [3]
Le programme principal et le thread qu’il a créé partagent trois

zones de la mémoire : le segment text qui comprend l’ensemble des
instructions qui composent le programme,le segment de données qui
comprend toutes les données statiques, initialisées ou non (c’est-à-dire
les constantes, les variables globales ou encore les chaînes de caractères)
et enfin le heap. Autant le programme principal que son thread peut
accéder à n’importe quelle information se trouvant en mémoire dans
18
CHAPITRE 3. PROCESSUS ET THREAD
ces zones. Par contre, le programme principal et le thread qu’il vient

de créer ont chacun leur propre contexte et leur propre pile.
Il existe plusieurs mécanismes de communication entre les threads

et les processus mais il est important de choisir le bon mécanisme de
communication en fonction des besoins de l’application et de gérer la
communication avec précaution pour éviter les problèmes de synchro-
nisation et de concurrence. (il doit être choisit avec précaution )
1. La première façon pour un processus de communiquer avec un thread
qu’il a lancé est d’utiliser les arguments de la fonction de démarrage
du thread et la valeur retournée par le thread que le processus prin-
cipal peut récupérer. C’est un canal de communication très limité
qui ne permet pas d’échange d’information pendant l’exécution du
thread.
2. Les signaux : le mécanisme de communication entre processus le
plus primitif sous Unix. Les signaux sont utilisés pour envoyer des
notifications entre les processus et les threads. Un processus peut
envoyer un signal à un autre processus ou à un thread pour l’informer
d’un événement ou d’une erreur. Les signaux peuvent être utilisés
pour arrêter ou suspendre un processus ou un thread c’est la notion
d’interruptions.
3. Les pipes : une méthode de communication unidirectionnels inter-
processus qui permet à deux processus de partager des données en
utilisant le système de fichiers qui permettent aux processus de com-
muniquer entre eux. Un processus peut écrire des données dans un
pipe, qui peuvent ensuite être lues par un autre processus. Les pipes
peuvent également être utilisés pour communiquer entre les threads
d’un même processus.
On peut créer un pipe avec l’appel système pertinemment nommé
pipe. Voici son prototype dans la bibliothèque <unistd.h> : int
pipe(int pipefd[2]) ;
19
Figure 3.1 – Pipe (tube)
4. Les sockets : Les sockets sont des mécanismes de communication bi-

directionnels qui permettent aux processus de communiquer à travers
un réseau. Les sockets peuvent être utilisés pour communiquer entre
les processus sur la même machine ou sur des machines distantes.
Les sockets peuvent également être utilisés pour communiquer entre
les threads d’un même processus.
5. Les files de message : Les files de message sont des mécanismes de
communication utilisés pour transférer des messages entre les pro-
cessus. Un processus peut envoyer un message à une file de message,
qui peut ensuite être lu par un autre processus. Les files de message
peuvent également être utilisées pour communiquer entre les threads
d’un même processus.
Le système ne crée pas automatiquement une file d’attente de

messages pour chaque thread. Au lieu de cela, le système crée une
file d’attente de messages uniquement pour les threads qui effectuent
des opérations qui nécessitent une file d’attente de messages.
20
Figure 3.2 – Envoie de message
6. Les mémoires partagées : Les mémoires partagées sont des régions

de mémoire qui peuvent être partagées entre les processus ou les
threads. Les processus ou les threads peuvent lire ou écrire des don-
nées dans la mémoire partagée pour communiquer entre eux. Les mé-
moires partagées doivent être protégées par des mécanismes de syn-
chronisation, tels que les verrous, pour éviter les conflits de concur-
rence.
Figure 3.3 – Partage de mémoire
21
3.2 Différence entre processus et thread :
Pour comprendre la différence entre ces deux notions on reprend la

définition de ces deux entités : une application se compose d’un ou
plusieurs processus. Un processus, en termes les plus simples, est un
programme en cours d’exécution. Un ou plusieurs threads s’exécutent
dans le contexte du processus. Un thread est l’unité de base à laquelle
le système d’exploitation alloue le temps processeur. Un thread peut
exécuter n’importe quelle partie du code de processus, y compris les
parties actuellement exécutées par un autre thread.
Les processus et les threads sont des séquences d’exécution indépen-

dantes. La principale différence est la suivante : Les threads (du même
processus) s’exécutent dans un espace mémoire partagé, tandis que les
processus s’exécutent dans des espaces mémoire différents.
Le tableau ci-dessous illustre les principales différences entres process
et thread [12] :
22
Figure 3.4 – Comparaison entre Thread et Processus
En principe les threads est une partie d’un processus qui permettent
l’exécution de nombreuses taches simultanément Dans un même proces-
sus, plusieurs threads peuvent être exécutés en parallèle, chacun ayant
son propre chemin d’exécution et partageant l’espace mémoire du pro-
cessus. Les threads sont souvent utilisés pour effectuer des tâches en
arrière-plan ou pour améliorer la réactivité d’un programme, car ils
permettent de traiter plusieurs tâches simultanément sans bloquer l’exé-
cution du programme principal.
23
CONCLUSION
Utilité des threads :
Les programmes multithreads peuvent améliorer les performances par

rapport aux programmes parallèles traditionnels qui utilisent plusieurs
processus. De plus, des performances améliorées peuvent être obtenues
sur des systèmes multiprocesseurs utilisant des threads. [7]
1. Gestion des threads : Gestion des threads ; c’est-à-dire que la créa-
tion de threads et le contrôle de leur exécution nécessitent moins
de ressources système que la gestion de processus. La création d’un
thread, par exemple, ne nécessite que l’allocation de la zone de don-
nées privée du thread, généralement 64 Ko, et deux appels système.
La création d’un processus est beaucoup plus coûteuse, car tout l’es-
pace d’adressage du processus parent est dupliqué.
L’API ( interface de programmation d’application)de la biblio-

thèque de threads est également plus facile à utiliser que la biblio-
thèque de gestion des processus. La création de thread ne nécessite
que la sous-routine pthreadcreate.
2. Communications inter-threads : La communication inter-thread est
beaucoup plus efficace et plus facile à utiliser que la communication
inter-processus. Étant donné que tous les threads d’un processus
partagent le même espace d’adressage, ils n’ont pas besoin d’utiliser
24
de mémoire partagée. Protégez les données partagées contre les accès

simultanés à l’aide de mutex ou d’autres outils de synchronisation.
Les fonctionnalités de synchronisation fournies par la bibliothèque

de threads facilitent la mise en œuvre d’outils de synchronisation
flexibles et puissants. Ces outils peuvent remplacer les installations
de communication inter-processus traditionnelles, telles que les files
d’attente de messages. Les canaux peuvent être utilisés comme che-
min de communication inter-thread.
3. Systèmes multiprocesseurs : Sur un système multiprocesseur, plu-
sieurs threads peuvent s’exécuter simultanément sur plusieurs pro-
cesseurs. Par conséquent, les programmes multithreads peuvent s’exé-
cuter beaucoup plus rapidement que sur un système monoprocesseur.
Ils peuvent également être plus rapides qu’un programme utilisant
plusieurs processus, car les threads nécessitent moins de ressources
et génèrent moins de surcharge. Par exemple, changer de thread dans
le même processus peut être plus rapide, en particulier dans le mo-
dèle de bibliothèque M :N où les changements de contexte peuvent
souvent être évités. Enfin, un avantage majeur de l’utilisation des
threads est qu’un seul programme multithread fonctionnera sur un
système monoprocesseur, mais peut naturellement tirer parti d’un
système multiprocesseur, sans recompilation.
4. Limites : La programmation multithread est utile pour implémenter
des algorithmes parallélisés utilisant plusieurs entités indépendantes.
Cependant, dans certains cas, plusieurs processus doivent être utili-
sés au lieu de plusieurs threads.
De nombreux identificateurs, ressources, états ou limitations du sys-
tème d’exploitation sont définis au niveau du processus et, par consé-
quent, sont partagés par tous les threads d’un processus. Par exemple,
les ID d’utilisateur et de groupe et leurs autorisations associées sont
gérés au niveau du processus. Les programmes qui doivent attribuer
25
différents ID utilisateur à leurs entités de programmation doivent

utiliser plusieurs processus, au lieu d’un seul processus multithread.
D’autres exemples incluent les attributs du système de fichiers, tels
que le répertoire de travail actuel, ainsi que l’état et le nombre maxi-
mal de fichiers ouverts. Les programmes multithreads peuvent ne pas
être appropriés si ces attributs sont mieux gérés indépendamment.
Par exemple, un programme multiprocessus peut laisser chaque pro-
cessus ouvrir un grand nombre de fichiers sans interférence d’autres
processus.
Source : IBM.com traduit de l’anglais
26
BIBLIOGRAPHIE
[1] C/c++ : Les thread, march 2019.

[2] Java - créer un thread, 2023.
[3] Université catholique du Lovain. communication entre thread.
[4] Amine DHRAIEF. Système d’exploitation-les processus les
threads.
[5] J.M. Doudoux. Développons en java - les threads.
[6] Université du Québec à Chicoutini. :systéme d’exploitation -les
threads-8inf341.
[7] IBM.com. Benifits of threads.
[8] Leslie Lamport. How to make a multiprocessor computer that
correctly executes multiprocess programs. IEEE Transactions
on Computers C-28, 9 :690–691, September 1979.
[9] Dominique Liard. Tuto langage c : Introduction à la program-
mation multi-threads avec le langage c.
[10] Nabila Salmi. Systéme d’exploitation Cours et exercices cor-
rigés. page bleue, 2017.
[11] techno science. Thread (informatique) - définition et explica-
tionsquot.
[12] WayToLearnX. :différence entre thread et processus en java.
27

Projet SE PDF

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

Projet SE PDF

Transféré par

Droits d'auteur :

Formats disponibles

RÉPUBLIQUE ALGÉRIENNE DÉMOCRATIQUE ET POPULAIRE

Ministère de l’Enseignement Supérieur et de la Recherche Scientifique

Thème : les threads

Module : Système d’exploitation

En : 2ème année licence informatique

Année universitaire :2023-2022.

1 Généralités sur les threads 3

2 Gestion et implémentation de thread 13

1.1 les threads . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

2.1 Thread utilisateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

3.1 Pipe (tube) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

2.1 Avantages et inconvenients des threads utilisateur . . . . . . . . . . 14

1 création d’un thread . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

Le modèle de processus introduit jusqu’à ce point suppose qu’un processus

Toutefois, il est plus intéressant et plus performant de pouvoir exécuter

processus d’avoir plusieurs flots d’exécution multiples : ce processus est alors

GÉNÉRALITÉS SUR LES THREADS

1.1 La définition de threads :

Un thread appelé parfois processus léger est une séquence d’instructions

En première analyse, on peut imaginer les threads comme des processus

-Chaque thread dispose personnellement d’une pile et d’un contexte d’exé-

sieurs tâches en parallèle.

Un thread est l’unité de base de l’utilisation du CPU, il comporte :

Figure 1.1 – les threads

Il partage avec les autres threads appartenant au même processus :

Un processus traditionnel (poids lourd) a un seul thread : si un proces-

1.2 Des exemples sur les threads :

accélère le temps d’exécution.[4]

1.3 Les avantages d’un thread :

Rendre une application Multithreadée peut permettre à une partie de

1.3.2 Partage des ressources :

Les processus peuvent se partager des ressources grâce à des techniques

Alloué de la mémoire et de ressources pour la création des processus

1.3.4 Scalabilité (passage à l’échelle) :

Les avantages du multithreading peuvent être considérablement aug-

1.4 La création et l’execution d’un thread :

La création d’un thread en programmation dépend du langage de pro-

En C, la bibliothèque « threads.h » fournit une fonction « thrd_create

1.4.1 Algorithme de creation d’un thread :

La routine pthread_create() crée un processus léger qui exécute la

Algorithm 1 création d’un thread

Cette routine crée et lance le thread immédiatement en exécutant la

Si la création du thread réussit, la fonction pthread_create retourne 0

1.4.2 Les paramètres de la fonction pthread_create :

1. Le paramètre *thread est un pointeur de type pthread_t : le type

Algorithm 2 "hello world" Pthreads program

1.4.4 Explication et détails :

In main : creating thread 0

GESTION ET IMPLÉMENTATION DE THREAD

2.1 Les modéles de multithreading :

L’implémentation des threads varie considérablement d’une plateforme

— Plusieurs-à-un :les threads sont gérés au niveau utilisateur(threads

2.1.1 Threads utilisateur :

L’implémentation des threads en espace utilisateur implique que le par-

Table 2.1 – Avantages et inconvenients des threads utilisateur

Figure 2.1 – Thread utilisateur

le tableau ci-dessus 2.1 montre : Les avantages et les inconvenients des

2.1.2 Thread noyau :

L’implémentation des threads en espace noyau implique que le systéme

Table 2.2 – Avantages et Inconvenients des threads noyau

lancés, où à chaque création d’un nouveau thread, une nouvelle entrée

Figure 2.2 – Thread noyau

2.1.3 Threads hybrides N :M