Université Tunis El Manar Institut Supérieur d’informatique
Programmation Système sous
UNIX
Préparé par : Dr. Najar Yousra
Email :
[email protected] Niveau : 2éme année ingénieur
Programmation Système sous UNIX
2 éme ing 1
Les Threads
La notion des Threads
Un thread une unite basique de l’utilization du CPU; Il
contient
- thread ID (TID)
- program counter, (CP/CO)
- register set,
- Et une pile.
Il partage avec les threads qui appartiennent au même
processus son segement de code, et données, et d’autres
ressources du système, comme les fichiers et le signaux.
• Un processus traditionnel (processus lourd) il a au moins un
thread de contrôle
• Lorsqu’un processus a plus qu un thread de controle il peut
executer plusieurs parties de son code en paralléle.
La notion des Threads
• La plus part des OS sont multithreadeds. Plusieurs
threads opérent dans le kernel pour executer des taches
spécifiques comme : géstion des périphiriques, gestion de
la mémoire, des intérruptions ……
La notion des Threads
• Exemple 1 : Microsoft Word peut avoir
- Un thread pour afficher les graphiques,
- Un autre thread pour répondre aux tapes du clavier de l’utilisateur,
- Un troisième pour faire la verification synthaxique en arrière plan.
• Exemple 2 :Web browser peut avoir
- Un thread pour télécharger les fichiers
- Un thread pour chaque page web
- Un serveur Web est multithreaded : Le serveur va créer un thread qui
reste à l’ecoute de des requests de clients et puis il crée un thread par
traiter les demandes (un par request) puis retourne à l’écoute
Les modèles du Multithreading
• Le support des thread peut être assurer à deux niveaux
niveau user et niveau kernel
• User threads sont supportés par les threads du kernel, alors
que les threads du kernel sont gérés par l’operating system.
• Une relation doit exister entre les user threads et les kernel
threads.Trois modèles sont utilisés dans ce cadre:
- many-to-one model,
- one-to-one model,
- many-to many model.
Les modèles du Multithreading
Many-to-one model
Le many-to-one model associe à plusieurs user-level threads un
seul kernel thread. La gestion des threads est faite par thread
library dans l’espace de l’utilisateur.
- Toute l’opération se bloque lorsque un
thread est bloqué.
- Parce qu un seul thread accéde au thread
du kernel on ne peut pas executer des
threads en paralléle avec des multicores .
Les modèles du Multithreading
One-to-one model
one-to-one model associe à chaque user thread un kernel
thread. Il fournit plus de concurrence que le modèle many-to-
one en permettant à un autre thread de s’exécuter lorsqu’un
thread fait un appel système bloquant. Il permet également à
plusieurs threads de fonctionner en parallèle sur des
multiprocesseurs.
Le seul inconvénient de ce modèle est que la
création d’un thread utilisateur nécessite la
création du thread noyau correspondant.
Comme la création de threads du noyau peut
affecter les performances d’une application, la
plupart des implémentations de ce modèle
limitent le nombre de threads supportés par le
système.
Multithreading Models
Many-to-many model
The many-to-many model associe plusieurs user-level threads
au meme nombre de ou à nombre inférieur de kernel threads.
The many-to-many : les devloppeurs
peuvent créer le nombre nécessaire de
user threads, et ils peuvent s’executer en
paralléle sur une architecture
multiprocessor. Egalement quand un
thread est bloqué il ne bloque pas les
autres,
Multithreading
- Main program a.out est le "heavy weight" process.
•a.out veut faire du travail en parallel crée 3 thread qui s
executent en paralléle (multitasking)
•Chaque thread a ses vriables locales, mais partage les
ressources de a.out.
•Le traitement du thread peut etre définit comme une function à
executer du code du père
•Threads partage et communique à travers la mémoire donc il
faut synchroniser.
•Les threads sont crées et tués mais le processus principal
continue à s’executer
Multithreading Operations (POSIX)
Thread library fournit au programmeur une API pour créer et
gérer des threads. Il existe deux manières principales
d'implémenter une bibliothèque thread .
Trois bibliothéques de thread existent : POSIX Pthreads,
Windows, et Java.
- Pthreads, une extension de POSIX standard, elle fournit
une bibliothéque du user-level et kernel-level.
- Windows thread library fournit une biblithéque kernel-
level pour Windows.
- Java thread API créer des user threads gérer par des
programmes Java,
Multithreading Operations (POSIX)
Pthreads fait référence à la norme POSIX (IEEE 1003.1c) définissant une
API pour la création et la synchronisation de threads. Il s'agit d'une
spécification pour le comportement des Threads
.
1. Thread management: creation, detachement, et jointure des threads, etc. elle
inclue des fonctions qui modifient les attribues des threads set/query thread
(joinable, scheduling etc.)
2. Mutexes: Mutex fonctions qui bloquent et reveillent sur mutex,
3. Condition variables: Utilisation des variables partagées.
Multithreading Operations (POSIX)
Gestion des Threads :
Création des Threads
int pthread_create (pthread_t *thread ,
pthread_attr_t *attr,
void *nomfonction,
void *arg );
- The pthread_create retourne thread ID dans l argument thread.
- Le paramétre attr est utilisé pour préciser les paramétres du thread. Par défaut il
estégal à NULL
- Nomfunction est une function C routine que le thread va executer.
Multithreading Operations (POSIX)
Suspension du Thread
int pthread_join (int threadId, void *status)
subroutine bloque le thread appellant la terminaison d’un autre. Retourne l’état de
terminaison dans status.
Retourne 0 or -1.
Terminaison du Thread
- Cet appel système termine le thread appellant ( precise une valeur de retour)
void pthread_exit(int returnvalue )
- Le thread est tué par un autre:
int pthread_cancel(pthread_t thread)
Thread identifier
- Le thread TID est donné par:
pthread_t pthread_self (void)
Multithreading Operations (POSIX)
Example (thread-pid.c) > gcc -o pthread-pid thread-pid.c
# include < unistd . h> > pthread-pid
# include < pthread . h> pid de main = 24133
# include < stdio. h> pid du thread fils = 24136
Multithreading Operations(POSIX)
Application : Ecrire un prog.c qui implémente cet arbre de threads.
Creates two threds A and B and
waits for their termination
Principal thread
Creates the thread C and
Thread B waits for its termination
Thread A
The routine that A, B and C execute
: prints an alphabitic letter n time, Thread C
The letter and the n are parameters
to the function.
Multithreading Operations (POSIX)
Application
