TP Systèmes d'exploitation - Linux : Les threads

Transcription

1 TP Systèmes d'exploitation - Linux : Les threads 1 Description D'après Thread = processus léger Un thread peut en créer d'autres, tous ces threads exécutent alors le même programme, mais chaque thread peut exécuter une partie différente du programme à un instant donné. Contrairement à la création d'un processus fils à partir d'un processus père (avec recopie de toutes les ressources du père), un thread va partager les ressources (espace mémoire, descripteurs de fichiers,..) du thread qui l'a créé (donc attention si un thread ferme un fichier, les autres threads enfants ou parents ne pourront plus lire et écrire dans ce fichier!). De même si un thread appelle une des fonctions «exec» alors tous les autres threads se terminent. Synchronisation de threads : il existe une fonction «join» qui permet de dire au processus qui crée les threads d'attendre leur fin avant de se terminer. 2 Les fonctions de la librairie «pthread.h» D'après tramonta : #include <pthread.h> int pthread_create( pthread_t * thread, pthread_attr_t * attr, void * (*start_routine)(void *), void * arg ); int pthread_join(pthread_t th, void **thread_return); int pthread_mutex_lock(pthread_mutex_t *mutex); int pthread_mutex_unlock(pthread_mutex_t *mutex); int pthread_cond_wait(pthread cond t *cond, pthread mutex t *mutex); int pthread_cond_signal(pthread_cond_t *cond); int pthread_cond_broadcast(pthread cond t *cond); Create / Join Create permet de créer un thread qui peut être exécuté à n'importe quel moment. Dès qu'il est créé il peut alors s'exécuter alors que le processus qui l'a créé est terminé (mais attention du coup il lui manque toutes les ressources détenues par le processus appelant!) Join est la fonction permettant de suspendre l'exécution du thread appelant jusqu'à ce que le thread passé en paramètre achève son exécution. La valeur de retour du thread peut être retournée, sinon on appelle la fonction avec NULL. Une précaution à prendre : un thread ne doit jamais appeler pthread_join sur lui-même (code erreur : EDEADLK), on peut alors utiliser la fonction «equal» de la manière suivante : if (!pthread_equal (pthread_self (), other_thread)) pthread_join (other_thread, NULL);

2 Attributs des mutex : Les threads linux ne supportent qu'un seul attribut pour un mutex, le type de mutex, qui peut être : PTHREAD_MUTEX_FAST_NP : mutex «rapide» PTHREAD_MUTEX_RECURSIVE_NP : mutex «récursif» PTHREAD_MUTEX_ERRORCHECK_NP : mutex «vérificateur d'erreurs» En C le type d'un mutex est défini par «pthread_mutex_t» Par défaut le mutex est fast, mais on peut initialiser les mutex soit statiquement : fast = PTHREAD_MUTEX_INITIALIZER; pthread_mutex_t rec = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP; pthread_mutex_t errck= PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP; soit grâce à la fonction int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr); Note : tous les suffixes _NP ou _np indiquent une extension non-portable à POSIX. pthread_mutex_lock : Si le mutex est déjà bloqué par le thread appelant la fonction «lock», le comportement va dépendre du type de mutex : si le «mutex» est de type rapide, le thread appelant est suspendu jusqu'à ce que le mutex soit débloqué, et donc le thread est débloqué si le «mutex» est de type récursif, la fonction est exécutée et retourne immédiatement, en enregistrant le nombre de fois où le thread a bloqué le mutex si le «mutex» est de type vérif-erreur, la fonction retourne immédiatement avec l'erreur EDEADLK Une autre fonction peut être utilisée «pthread_mutex_trylock()», fait la même chose sauf qu'elle ne bloque pas le thread appelant si le mutex est déjà bloqué par un autre thread et retourne immédiatement l'erreur EBUSY pthread_mutex_unlock : débloque le «mutex», posé comme détenu par le thread appelant, et : si le «mutex» est de type rapide, pthread_mutex_unlock renvoie toujours à l'état débloqué si le «mutex» est de type récursif, décrémente le compteur de blocage du «mutex»; c'est seulement quand il a obtenu 0 que le «mutex» reste à l'état bloqué si le «mutex» est de type vérificateur d'erreurs, alors la fonction vérifie que : le «mutex» est bloqué en entrée, et qu'il était bloqué par le thread appelant sinon, un code d'erreur est retourné et le «mutex» reste inchangé

3 les «mutex» rapides et récursifs seront débloqués plutôt par un thread autre que le leur Variables de condition Une variable de condition est un mécanisme de synchronsiation qui permet aux threads de : suspendre une exécution (et abandonne les processeurs) jusqu'à ce qu'une condition (prédicat) sur des variables partagées devienne vraie Opérations de base : signale une condition (quand le prédicat devient vrai) à n'importe lequel l'attendant ; attend sur une condition, suspendant l'exécution du thread jusqu'à ce qu'un autre thread signale la condition. Elle se définit en C avec le type «pthread_cond_t». On peut initialiser une variable de condition statiquement (comme les mutex) de la manière suivante : pthread_cond_t condition_var = PTHREAD_COND_INITIALIZER; pthread_cond_signal : redémarre un thread qui attend sur «cond» : si aucun thread attend, il ne se passe rien si plusieurs attendent sur le «cond», alors un seul sera redémarré (sans spécifier lequel) pthread_cond_broadcast : redémarre tous les threads qui attendent sur «cond» pthread_cond_wait : Le thread appelant doit détenir le «mutex» en entrée de la fonction atomiquement débloque le «mutex» (comme avec pthread_unlock_mutex) et attend que «cond» soit signalée l'exécution du thread appelant est suspendue et ne consomme aucun temps CPU jusqu'à ce que «cond» soit «signalée» avant de retourner au thread appelant, la fonction re-bloque «mutex» (comme avec pthread_lock_mutex) Une condition doit toujours être associée avec des mutex : si un thread obtient toujours le mutex avant de signaler une condition, alors l'atomicité du unlock/suspendu dans le wait garantit que la condition ne peut être signalée (et donc sera ignorée) entre le unlock et le suspendu. Erreurs ESRCH : Aucun thread correspondant à th n'a pu être trouvé. EINVAL : Le thread th a été détaché. EINVAL : Un autre thread attend déjà la mort de th. EDEADLK : L'argument th représente le thread appelant.

4 3 Les fonctions de la librairie «semaphore.h» #include <semaphore.h> int sem_init(sem_t *, int, unsigned); int sem_destroy(sem_t *) ; int sem_wait(sem_t *); int sem_post(sem_t *); sem_t *sem_open(const char *, int,...); int sem_close(sem_t *); L'utilisation de sémaphores va permettre aux threads de se bloquer en attente de nouvelles tâches. Un sémaphore est un compteur qui peut être utilisé pour synchroniser plusieurs threads. Chaque sémaphore dispose d'une valeur de compteur, qui est un entier positif ou nul. 2 opérations de base : sem_wait : permet d'attendre en décrémentant la valeur du sémaphore d'une unité. Si la valeur est déjà à 0 l'opération est bloquante jusqu'à ce que la valeur du sémaphore redevienne positive (en raison d'une opération de la part d'un autre thread). Lorsque la valeur du sémaphore devient positive, elle est décrémentée d'une unité et l'opération d'attente se termine. Il existe d'autres fonctions qui permette de ne pas bloquer forcément le processus mais de retourner un message d'erreur quand la valeur du sémaphore est nulle (sem_trywait()), ou de bloquer le processus un temps (sem_timedwait()) sem_post: permet de réveiller en incrémentant la valeur du sémaphore d'une unité. Si le sémaphore était précédemment à zéro et que d'autres threads étaient en attente sur ce même sémaphore, un de ces threads est débloqué et son attente se termine (ce qui ramène la valeur du sémaphore à zéro). sem_init: permet d'initialiser la variable sem_t représentant le sémaphore utilisé, le 2 e paramètre doit être mis à 0 et le dernier paramètre représente la valeur initiale du sémaphore. Il est conseillé de détruire un sémaphore qui n'est plus utilisé par la fonction sem_destroy(). Exemple : #include <stdio.h> #include <stdlib.h> #include <sys/types.h> #include <unistd.h> #include <semaphore.h> #include <pthread.h> /* PAS FORCEMENT UTILE POUR LES SEMAPHORES */ #define TRUE 1 #define FALSE 0 #define COUNT_DONE 10 int cpt=0; /* UTILE POUR LES SEMAPHORES */ sem_t mutex0, mutex1;

5 /* UTILE POUR LES THREADS */ void *functionaffiche0(); void *functionaffiche1(); void *functionaffiche0(void *arg) while (TRUE) sem_wait(&mutex0); printf("je suis le thread %ld\n",pthread_self()); sem_post(&mutex1); /* Pour s'arrêter */ cpt++; if (cpt > COUNT_DONE) exit(0); void *functionaffiche1(void *arg) int i, result, p; p = (int) arg; while (TRUE) sem_wait(&mutex1); printf("%d>>je suis le thread %ld\n",p,pthread_self()); for (i=0;i<=5;i++) printf("\t%d",i); printf("\n"); sem_post(&mutex0); /* Pour s'arrêter */ cpt++; if (cpt > COUNT_DONE) exit(0); int main(int argc, char **argv) pthread_t thread0, thread1; int i=1; void *res; /* initialisation des sémaphores */ sem_init(&mutex0, 0, 1); sem_init(&mutex1, 0, 0); /* création des threads avec fonction à exécuter */ pthread_create( &thread0, NULL, &functionaffiche0, NULL); pthread_create( &thread1, NULL, &functionaffiche1, (void *)i);

6 /* attend que tous les threads soient terminés */ pthread_join( thread0, &res); pthread_join( thread1, &res); return(0); Exercice 1 exercice affichage à l'aide de threads. Vous reprendrez l'exercice 2 du TP précédent sur les fork(), et créerez 3 processus ou threads qui, à partir du fichier listenbpremiers, affichent l'un les 10 premiers nombres, puis l'autre les 10 suivants, puis le dernier affiche les 10 suivants. Vous utiliserez des sémaphores et les fonctions sem_wait et sem_post. Dans les exercices suivants, vous n'oublierez pas d'afficher des messages indiquant les numéros des threads et leur nom afin de pouvoir vérifier que vos programmes réalisent correctement ce que vous désirez. Ex : vous donnerez pour chaque lecteur et chaque rédacteur le numéro passé à chacun d'eux ainsi que le nombre de lecteurs dans la base de données pour chaque lecteur. Exercice 2 problème classique : Lecteurs/Rédacteurs Vous écrirez les programmes permettant de simuler ce problème classique vus en cours et TD, à l'aide dans un premier temps des sémaphores (fonctions sem_wait et sem_post), puis dans un deuxième temps à l'aide de mutex (fonctions pthread_mutex_lock, pthread_mutex_unlock). Exercice 3 problème classique : Producteurs/Consommateurs Vous écrirez les programmes permettant de simuler ce problème classique vus en cours et TD, à l'aide dans un premier temps des sémaphores, puis dans un deuxième temps à l'aide de mutex et de variables de condition si nécessaires.