Université d’Ain Temouchent Belahdj Bouchaib

Faculté des sciences et technologies – département mathématique et informatique

Licence informatique SI L3 Système d’exploitation 2

Fiche TP1 Threads & GCC

Concepts de base
- Pour utiliser les threads il faut ajouter la bibliothèque pthreads dans un programme
C:
Le fichier de déclarations standard :

#include <pthread.h>
- La déclaration d’un ou plusieurs descripteurs de threads comme suit :
pthread_t T1, T2; /* descripteurs de thread */

- Un nouveau thread est créé en utilisant l'appel à la fonction :

int pthread_create(pthread_t *pthread, const pthread_attr_t *attr, void *(*fonction)(void *), void *arg);

• pthread : Pour récupérer l’identité du thread qui est créé

• attr : Attributs du thread. Si attr est NULL, la valeur par défaut est prise
• fonction : Fonction à exécuter en parallèle
• arg : arguments de la fonction.
Cette routine renvoie zéro si elle réussit et une valeur non nulle sinon, correspondant à
l’erreur survenue.
Remarque : 1. pthread _create impose un format strict en ce qui concerne le prototype de la
fonction qui sera exécuter par le nouveau thread créé, la fonction doit obligatoirement avoir
un seul paramètre de type pointeur sur void (void*) et doit retourner une seule valeur de type
void*. Exemple void *f(void *a).
2. le passage du paramètre se fait par le biais pthread _create.

- L’identité d’un thread (son numéro) :

pthread_t pthread_self(void); //elle renvoi le pthread_t du thread courant.

- Égalité ente threads :

int pthread_equal(pthread_t t1, pthread_t t2); // permet de comparer deux identifiants

Remarque : 3. lors de la fin d’exécution de la routine qui a créé un thread cela implique aussi
la fin de l’exécution de ce dernier.
4. Lorsque la fonction principale d’un thread se termine, celui-ci est éliminé. Cette
fonction doit renvoyer une valeur de type void * qui pourra être récupérée dans un autre fil
d’exécution. Il est aussi possible d’invoquer la fonction pthread_exit(), qui met fin au thread
appelant tout en renvoyant le pointeur void * passé en argument. On ne doit naturellement pas
invoquer exit(), qui mettrait fin à toute l’application et pas uniquement au thread appelant.

- Mettre fin à l’exécution d’un thread

void pthread_exit (void * retour);

- Attendre la fin d’un thread (synchronisation) :

int pthread_join (pthread_t thread, void ** retour);
 Université d’Ain Temouchent Belahdj Bouchaib
Faculté des sciences et technologies – département mathématique et informatique

Licence informatique SI L3 Système d’exploitation 2

• Appel bloquant jusqu’ à ce que le thread thread termine (ou soit résilié, pthread_cancel)

• Si l’argument retour n’est pas NULL, il pointe vers la valeur de retour du thread (ou,
pointe vers PTHREAD_CANCELED en cas de résiliation).
• pthread_join revoie 0 en cas de succès (errno n’est pas positionné en cas d’échec).

- Détacher un thread :
int pthread_detach (pthread_t thread);

Lorsqu’un thread ne renvoie pas de valeur intéressante et qu’il n’a pas besoin d’être attendu par
un autre thread, on peut employer la fonction pthread_detach(), qui lui permet de disparaître
automatiquement du système quand il se termine. Cela autorise la libération immédiate des
ressources internes à la bibliothèque concernant ce thread (pile et variables automatiques). Le
mécanisme n’est pas sans rappeler le passage des processus à l’état Zombie en attendant qu’on
lise leur code de retour et l’emploi de SIG_IGN pour le signal SIGCHLD du processus parent.

- Annuler un thread :
int pthread _ cancel ( pthread_t thread) ;// Permet de d'"annuler" (de terminer) un
thread.
• Un thread peut vouloir annuler un autre thread. Il envoie alors une demande
d’annulation, qui sera prise en compte ou non, en fonction de la configuration du thread
récepteur.
• Lorsqu’un thread est annulé, il se comporte exactement comme s’il invoquait la fonction
pthread_exit() avec l’argument spécial PTHREAD_CANCELED.
• Le thread récepteur peut accepter la requête, la refuser ou la repousser jusqu’à atteindre
un point d’annulation dans son exécution
• la fonction pthread_cancel(), qui renvoie 0 si elle réussit, ou l’erreur ESRCH si le thread
visé n’existe pas.
 Université d’Ain Temouchent Belahdj Bouchaib
Faculté des sciences et technologies – département mathématique et informatique

Licence informatique SI L3 Système d’exploitation 2

Exercice 1.
Soit le programme C qui permet de créer 5 threads
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#define NB_THREADS 5
void *fn_thread (void *numero);
static int compteur = 0;
int
main (void)
{
pthread_t thread[NB_THREADS];
int i;
int ret;
for (i = 0; i < NB_THREADS; i ++)
if (pthread_create(&thread[i], NULL, fn_thread, &i) != 0) {
fprintf(stderr, "%s", strerror(ret));
exit(EXIT_FAILURE);
}
while (compteur < 40) {
fprintf(stdout, "main : compteur = %d \n", compteur);
//sleep(1);
}
for (i = 0; i < NB_THREADS; i ++)
pthread_join(thread[i], NULL);
return EXIT_SUCCESS;
}
void *fn_thread (void *num)
{
int numero = *((int *) num);
while (compteur < 40) {
//usleep(numero * 100000);
compteur ++;
fprintf(stdout, "Thread %d : compteur = %d \n",
numero, compteur);
}
pthread_exit(NULL);
}

1. Compilez ce programme et exécutez le sous linux en utilisant la commande suivante :

gcc – o nom_fichier_executable nom_du_programme.c -lpthread
2. Que retourne ce programme. ? Expliquez. ?
 Université d’Ain Temouchent Belahdj Bouchaib
Faculté des sciences et technologies – département mathématique et informatique

Licence informatique SI L3 Système d’exploitation 2

Exercice 2.
Soit le programme C suivant :
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
void *fn_thread (void *inutile)
{
char chaine[128];
int e = 0;
fprintf(stdout, "Thread : entrez un nombre :");
while (fgets(chaine, 128, stdin) != NULL)
if (sscanf(chaine, "%d", &e) != 1)
fprintf(stdout, "un nombre SVP :");
else
break;
int *s=malloc(sizeof(int));
*s=e;

pthread_exit(s);
}
int main (void)
{
int i;int *s;
int ret;
void **retour;
pthread_t thread;
if ((ret = pthread_create(&thread, NULL, fn_thread, NULL)) != 0) {
fprintf(stderr, "%s\n", strerror(ret));
exit(EXIT_FAILURE);
}
pthread_join(thread, (void **) &s);
if (retour != PTHREAD_CANCELED) {

fprintf(stdout, "main : valeur lue = %d\n", *s);

}
return(EXIT_SUCCESS);
}

1 . Déroulez le programme en expliquant ce que fait ce programme.

 Université d’Ain Temouchent Belahdj Bouchaib
Faculté des sciences et technologies – département mathématique et informatique

Licence informatique SI L3 Système d’exploitation 2

Exercice 3.

Réalisez un programme C en utilisant le mutithreading permettant de faire la somme de

deux matrices A et B de N éléments. La somme de chaque ligne est calculée avec des threads
indépendants en parallèle.

Exercice 4.
Réalisez un programme C en utilisant le mutithreading permettant de faire la maultiplication de
deux matrices A et B de N éléments. Le calcul de chaque ligne doit être effectué par un thread.
Rappel de la multiplication thread :