Vous êtes sur la page 1sur 6

TP N 2 : les Threads sous Linux

TP N° 2 : Les threads sous linux

Processus légers (threads)

Un processus UNIX est constitué d’un ensemble d’informations permettant au système


D’assurer le contrôle des ressources du processus (descripteurs des fichiers ouverts,
implantation en mémoire, etc.) ou son exécution (ordonnanceur, pile, signaux).
Contrairement à la fonction fork() qui effectue une recopie d’un processus en mémoire, le
mécanisme des threads (on parle aussi d’activités) permet de ne dupliquer que les
informations relatives à l’exécution du processus. Les informations relatives aux ressources
restent communes à toutes les activités d’un processus. Lors de la création de threads par un
processus, les threads posséderont le même pid, mais des identités d’activités (tid) différentes.
– Option de compilation : -lpthread
– Include : #include <pthread.h>

Fonctions POSIX de manipulation des processus légers (threads) :

Création d’un thread

Crée un nouveau thread et lui fait exécuter la fonction start_routine en lui passant arg comme
premier argument. L’identifiant du thread est enregistré dans tid. Si attr est
NULL, les attributs par défaut sont utilisés (thread joignable, ordonnancement standard).
Self : identité d’un thread

pthread_t pthread_self(void) : Renvoie l’id du thread courant.


Attente de la mort d’un autre thread

1
TP N 2 : les Threads sous Linux

Suspend l’exécution du thread appelant jusqu’à ce que le thread identifié par tid achève son
exécution, soit en appelant pthread_exit() soit après avoir ´été annulé. Si thread_return ne vaut
pas NULL, la valeur renvoyée par tid y sera enregistrée.

Terminaison d’un thread

void pthread_exit(void *retval);

Termine l’exécution du thread appelant. L’argument retval est la valeur de retour du thread. Si
le thread est joignable, cette valeur de retour peut être consultée par un autre thread en
utilisant pthread_join(). Appelée dans le thread initial cette fonction a pour effet d’attendre la
fin de l’exécution des autres threads. Un appel implicite à pthread_exit() est fait lorsqu’un
thread autre que le thread initial sort de la fonction start_routine qui avait été utilisée pour le
créer.
Exercice N°1

#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
void * fct1()
{

printf("SUR DES THREADS \n");

void * fct2()
{

printf("TP N°2\n");

int main()
{

pthread_t tid1,tid2;
pthread_create(&tid1,NULL,fct1,NULL);
pthread_create(&tid2,NULL,fct2,NULL);
pthread_join(tid1,NULL);
pthread_join(tid2,NULL);
return 0;
}

2
TP N 2 : les Threads sous Linux

Q1: compiler ce programme avec le compilateur gcc.

Q2 : quelle est le résultat affiché par ce programme ?

Q1 : modifier ce programme pour que le message TP N°2 s’affiche avant le message SUR
DES THREADS

Exercice N°2

#include <pthread.h>
#include <stdio.h>

void* fct1(void *arg);


void* fct2(void *arg);
void* fct3(void *arg);
int main ( )
{
pthread_t threadA;
pthread_t threadB;
pthread_t threadC;

printf("debut execution de mes threads\n");


pthread_create(&threadA, NULL,fct1,NULL);
pthread_create(&threadB,NULL,fct2,NULL);
pthread_create(&threadC,NULL,fct3,NULL);

pthread_join(threadA,NULL);
pthread_join(threadB,NULL);
pthread_join(threadC,NULL);

printf("fin de mes threads\n");

return 0;
}

void* fct1(void *arg)


{
int i;

printf("je suis le thread A\n");


for(i=1; i<=3; i++)
{ printf("%d\n",i);}

return (NULL);
}

3
TP N 2 : les Threads sous Linux
void* fct2(void *arg)
{
int i;
printf("je suis le thread B\n");
for(i=4; i<=6; i++)
{ printf("%d\n",i);}

return (NULL);
}

void* fct3(void *arg)


{
int i;
printf("je suis le thread C\n");
for(i=7; i<=10; i++)
{ printf("%d\n",i);}

return (NULL);
}

Q1: compiler ce programme avec le compilateur gcc.

Q2 : quelle est le résultat affiché par ce programme ?

Q3 : modifier ce programme pour que l'affichage est comme suite : 1 2 3 4 5 6 7 8 9 10

Exercice N°3

création de deux threads


On crée deux tâches ( threads ) pour exécuter chacune des deux fonctions : une affichera
des étoiles ’*’ et l’autre des dièses ’#’.

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<pthread.h>
//Fonctions correspondant au corps d’un thread(tache)
void *etoile(void *inutilise);
void *diese(void *inutilise);

//Remarque:le prototype d’une tâche doit être :


void *(*start_routine)(void *)

int main(void)
{
pthread_t thrEtoile, thrDiese;
//les ID des de 2 thread
setbuf(stdout, NULL);
//pas de tampon sur stdout
printf("Je vais créer et lancer 2 threads");
pthread_create(&thrEtoile, NULL, etoile, NULL);
pthread_create(&thrDiese, NULL, diese, NULL);

4
TP N 2 : les Threads sous Linux

//printf("J’attends la fin des 2 threads\n");


pthread_join(thrEtoile, NULL);
pthread_join(thrDiese, NULL);
printf("\nLes 2 threads se sont termines\n");
printf("Fin du thread principal\n");
pthread_exit(NULL);
return EXIT_SUCCESS;
}

void *etoile( void *inutilise)


{ int i;
char c1 = ’*’;

for(i=1;i<=200;i++)
{
write(1, &c1, 1);
// écrit un caractère sur stdout(descripteur 1)

return NULL;
}
void *diese(void *inutilise)

int i;

char c1 = ’#’;

for(i=1;i<=200;i++)

{
write(1, &c1, 1);
}
return NULL;
}
L’exécution de ce programme montre la parallélisation des
traitements effectués : la fonction etoile()s’exécute en
parallèle avec la fonction diese().

5
TP N 2 : les Threads sous Linux

Q1: compiler ce programme avec le compilateur gcc.

Q2 : quelle est le résultat affiché par ce programme ?

Q3 : modifier ce programme pour que résultat d'affichage est comme suite :

cas 1 : *#*#*#*#

cas 2 : ****####

Exercice N°4

Q1 / Ecrire un programme en c composé par 4 threads qui s'exécute en parallèle et chaque thread
exécute un traitement bien déterminé sur un tableau t de taille 10:
- thread 1: calcule la somme et le produit des éléments d'un t de taille 10
- thread 2: calcule l'élément max d'un tableau t
- thread 3 : calcule l'élément min d'un tableau t
- thread 4 : calcule le trie de tableau t

Q2/ refaire le même programme mais avec 4 processus fils (en utilisant la fonction fork)
Q3/ comparez le résultat de deux programmes

Vous aimerez peut-être aussi