Ecole Supérieure Polytechnique Privée de Monastir A. U.

: 2022/2023
Niveau : 3ème année
Département de Génie Informatique Enseignant : Y. SALAH

Systèmes d’exploitation
TP02 : Synchronisation des tâches

Objectifs :
- Synchronisation des tâches en utilisant le mécanisme Attendre/Signaler ou sémaphore.
- Application sur le mécanisme rédacteurs/lecteurs.

I. Synchronisation des tâches

Pour synchroniser deux tâches qui ont une interaction entre eux, on peut utiliser les deux fonctions
ATTENDRE et SIGNALER. Comme rappel la fonction ATTENDRE est une primitive du système
d'exploitation qui provoque la mise en attente de la tâche, la fonction SIGNALER est adressée à la
tâche qui s'est mise en attente et aura pour effet de la débloquer.
On considère les deux tâches suivantes :
Tâche1 (prio = 2) Tâche2 (prio = 1) Tâche de fond (prio = 0)
Afficher (T [1.1]) Afficher (T [2.1]) Afficher(tache de fond)
Attendre (1s) Attendre [ev1]
Afficher (T [1.2]) Afficher (T [2.2])
Signaler (ev1)
Afficher (T [1.3])

Le tableau suivant donne les fonctions d'algorithme et leurs équivalents en C++.

Algorithme C++
Prio SetThreadPriority(handle_tache, n) //n = priorité
ATTENDRE(ev) WaitForSingleObject(ev,INFINITE)
ATTENDRE(1s) Sleep(1000) // temps en ms
SIGNALER(ev) SetEvent(ev)
P(Mutex) WaitForSingleObject(Handle_Mutex, INFINITE)
V(Mutex) ReleaseMutex(Handle_Mutex)

Travail demandé:
- Compléter le programme ci-dessous.
- Exécuter le programme et afficher les résultats.
- Qu’est ce que vous remarquez ? Résoudre ce problème en utilisant un Mutex.
# include "stdio.h"
# include "windows.h"

HANDLE ev1;
HANDLE Handle_Mutex;
DWORD wMutex;

5
DWORD WINAPI nom_tache(LPVOID param)
{
// code de la tâche

return 0;
}

void main( )
{
HANDLE htache[3];
DWORD Data1, Data2, Data3;

Handle_Mutex = CreateMutex(NULL, FALSE, "MutexDeProtection");

ev1 = CreateEvent(NULL,TRUE,FALSE,NULL);
htache[0] = CreateThread(NULL, 0, nom_tache, &Data1, 0, NULL);
.
.
SetThreadPriority(htache[0], 2);
.
.
WaitForMultipleObjects(3, htache, TRUE, INFINITE);

CloseHandle(htache);
}

II. Application sur le mécanisme rédacteurs/lecteurs

On considère des véhicules circulant sur deux voies parallèles avec parfois des tronçons à voie
unique. Bien entendu, il ne peut y avoir deux véhicules circulant en sens inverses sur la voie unique.
Chaque véhicule est considéré comme une tâche séparée.
Tâche VéhiculeSensEst
{
SensEst_demande_VU( ) ;
Accéder sur la voie unique ;
SensEst_libére_VU( ) ;
}

Tâche VéhiculeSensOuest
{
SensOuest_demande_VU( ) ;
Accéder sur la voie unique ;
SensOuest_libére_VU( ) ;
}
- Créer les deux tâches : VehiculeSensEst et VehiculeSensOuest

VehiculeSensEst
{
for(int i=0; i<25; i++)
{
Sleep(rand()%100); // rand() donne une valeur aléatoire
0<r<1
SensEst_demande_VU() ;

6
 Sleep(rand()%100) ; // durée de passage dans la voie
unique
SensEst_libére_VU() ;
}
}

VehiculeSensOuest
{
for(int i=0; i<25; i++)
{
Sleep(rand()%100); // rand() donne une valeur aléatoire
0<r<1
SensOuest_demande_VU() ;
Sleep(rand()%100) ; // durée de passage dans la voie
unique
SensOuest_libére_VU() ;
}
}

On se donne comme objectif de résoudre ce problème de synchronisation dans les deux cas
suivants :
• Un seul véhicule à la fois sur la voie unique,
• La capacité de la voie est limitée à 5 véhicules.
Pour chaque cas développez les procédures SensEst_demande_VU( ) , SensEst_libére_VU( ),
SensOuest_demande_VU( ) , SensOuest_libére_VU( ).
Ces procédures doivent afficher à chaque fois l’état de la voie unique (c-à-d le nombre de
véhicule dans le sens Est et le nombre de véhicules dans le sens Ouest). On peut utiliser la
fonction suivante :

void printEtat( )
{
printf("%d Sens Est , %d Sens Ouest \n", nbEst, nbOuest);
}

On peut utiliser deux Sémaphores Se et So pour contrôler l’accès des véhicule dans le sens Est et
les véhicules dans le sens Ouest, à la voie unique, et un Mutex pour protéger les zones de
traitement.