Systèmes d'Exploitation II - Travaux Dirigés II : Le Multithreading
Systèmes d'Exploitation II - Travaux Dirigés II : Le Multithreading
Multithreading, Programming, Operating Systems · lab
Fiche de révisionGuide de TP
Rédigée à partir de ce document, puis vérifiée avant publication.
Ce travaux dirigés porte sur le multithreading dans les systèmes d'exploitation. Il permet de comprendre les concepts fondamentaux du multithreading, ses différences avec la multiprogrammation, ainsi que la gestion des threads en programmation avec la bibliothèque pthread. Le TP inclut des exercices pratiques pour créer, lancer et synchroniser des threads, ainsi qu'un projet de génération multithreadée de la suite de Fibonacci. Pour réaliser ce TP, il est nécessaire de disposer d'un environnement de développement supportant la bibliothèque pthread, ainsi que de connaissances de base en programmation C.
Le multithreading consiste à exécuter plusieurs threads au sein d'un même processus, partageant la mémoire et les ressources. Il se distingue de la multiprogrammation où plusieurs processus s'exécutent simultanément mais isolés en mémoire.
Un thread est plus léger qu'un processus, car il partage le même espace mémoire que les autres threads du processus. Les processus ont chacun leur propre espace mémoire. Dans une application où les données sont partagées en mémoire, il est préférable d'utiliser des threads plutôt que des processus pour faciliter la communication et réduire la surcharge.
Le TCB (Thread Control Block) est une structure de données qui contient les informations nécessaires à la gestion d'un thread, similaire au PCB (Process Control Block) pour les processus. Le TCB inclut notamment l'état du thread, ses registres, sa pile, et d'autres informations de contexte.
Considérez les deux fonctions suivantes exécutées par deux threads différents, partageant la variable globale pointer :
int *pointer = NULL;
void * writer_thread() {
while (1) {
if (pointer == NULL) {
pointer = malloc(sizeof(int));
*pointer = rand();
}
}
}
void *reader_thread() {
while (1) {
if (pointer != NULL) {
printf("pointer = %d", *pointer);
free(pointer);
pointer = NULL;
}
}
}
Lors de l'exécution simultanée de ces deux threads, une erreur de segmentation apparaît après un certain temps. Cette erreur provient d'un problème de concurrence sur la variable pointer. En effet, les deux threads accèdent et modifient pointer sans synchronisation, ce qui peut entraîner des accès à une zone mémoire libérée ou non encore allouée. Ce comportement non protégé provoque l'erreur de segmentation.
La création et le lancement d'un thread se font avec la fonction pthread_create. Voici un exemple de code :
pthread_t th1;
int ret;
ret = pthread_create(&th1, NULL, runDuThread, "1");
if (ret != 0) {
fprintf(stderr, "pthread_create error 1");
exit(0);
}
Le thread exécute la fonction runDuThread dont le prototype est :
void* runDuThread(void *param);
Le paramètre param est un pointeur passé en argument lors de la création du thread (ici la chaîne "1"). Il permet de transmettre des données au thread.
Lorsque la fonction main se termine, tous les threads lancés se terminent également. Pour éviter cela, il faut attendre la fin des threads avant de terminer le programme en utilisant :
(void) pthread_join(th1, (void *)&ret);
Le paramètre ret recevra la valeur retournée par la fonction pthread_exit(int val) appelée avant la terminaison du thread.
Écrire un programme qui crée deux threads :
Chaque thread doit exécuter une fonction spécifique qui réalise cet affichage.
Écrire un programme qui initialise une variable globale à 0, puis crée deux threads. Chaque thread incrémente cette variable N fois. À la fin de l'exécution de chaque thread, afficher la valeur finale de la variable.
Ce programme permet d'observer les effets de la concurrence sur une variable partagée sans mécanisme de synchronisation.
La suite de Fibonacci est définie par :
fib[0] = 0
fib[1] = 1
fib[n] = fib[n-1] + fib[n-2]
Écrire un programme multithreadé qui génère la suite de Fibonacci. Le fonctionnement attendu est le suivant :