C'est un code pas tres bien fait mais il a le merite d'etre explicite!
Il donne un exemple pour l'utilisation des semaphores dans la programation multitache sous windows
Source / Exemple :
// exemple de semaphore, zone critique et mutex
// par xian240482
#include "stdafx.h" // completement inutile mais impossible a retirer!
#include <windows.h>
#include <stdio.h>
// structure où l'on peu mettre tout les elements dont les threads
// ont besoin
struct s_pass
{
int numeros;
char chaine[20];
};
#define N 5 //nombre maximale de threads simultanés
// variables globales
int *test;
CRITICAL_SECTION Sync;
HANDLE semp,mut;
char texte[5000];
// Tache des threads
// Cette fonction simule un travail sur une variable texte, les
// sleep sont là pour alonger (point de vue temps) ce travail
void travail(char ajout[2])
{ strcat(texte,"J"); Sleep(1);
strcat(texte,"E"); Sleep(1);
strcat(texte," "); Sleep(1);
strcat(texte,"S"); Sleep(1);
strcat(texte,"U"); Sleep(1);
strcat(texte,"I"); Sleep(1);
strcat(texte,"S"); Sleep(1);
strcat(texte," "); Sleep(1);
strcat(texte,"L"); Sleep(1);
strcat(texte,"E"); Sleep(1);
strcat(texte," "); Sleep(1);
strcat(texte,ajout); Sleep(1);
strcat(texte,"."); Sleep(1);
strcat(texte," "); Sleep(1);
strcat(texte,"C"); Sleep(1);
strcat(texte,"A"); Sleep(1);
strcat(texte," "); Sleep(1);
strcat(texte,"M"); Sleep(1);
strcat(texte,"A"); Sleep(1);
strcat(texte,"R"); Sleep(1);
strcat(texte,"C"); Sleep(1);
strcat(texte,"H"); Sleep(1);
strcat(texte,"E"); Sleep(1);
strcat(texte," "); Sleep(1);
strcat(texte,"E"); Sleep(1);
strcat(texte,"T"); Sleep(1);
strcat(texte," "); Sleep(1);
strcat(texte,"J"); Sleep(1);
strcat(texte,"E"); Sleep(1);
strcat(texte," "); Sleep(1);
strcat(texte,"V"); Sleep(1);
strcat(texte,"A"); Sleep(1);
strcat(texte,"I"); Sleep(1);
strcat(texte,"S"); Sleep(1);
strcat(texte," "); Sleep(1);
strcat(texte,"M"); Sleep(1);
strcat(texte,"E"); Sleep(1);
strcat(texte," "); Sleep(1);
strcat(texte,"T"); Sleep(1);
strcat(texte,"E"); Sleep(1);
strcat(texte,"R"); Sleep(1);
strcat(texte,"M"); Sleep(1);
strcat(texte,"I"); Sleep(1);
strcat(texte,"N"); Sleep(1);
strcat(texte,"E"); Sleep(1);
strcat(texte,"R"); Sleep(1);
strcat(texte," "); Sleep(1);
strcat(texte,"!"); Sleep(1);
strcat(texte,"\n");
}
// thread testant un changement de variable globale et passage de parametre
unsigned long WINAPI DemarrerThread_test (void * Param)
{
s_pass pass;
pass=*(s_pass * ) Param;
printf("thread %i : son message est \"%s\"\n", pass.numeros,pass.chaine);
return 4;
}
// thread ne faisant rien de speciale
unsigned long WINAPI DemarrerThread_base (void * Param)
{
s_pass pass;
pass=*(s_pass * ) Param;
printf("thread %i : son message est \"%s\"\n", pass.numeros,pass.chaine);
return 4;
}
// Thread executant un travail : normalement le resultat est catastrophique
unsigned long WINAPI DemarrerThread_travail (void * Param)
{
char temp[2];
s_pass pass;
pass=*(s_pass * ) Param;
printf("thread %i : son message est \"%s\"\n", pass.numeros,pass.chaine);
sprintf(temp,"%i",pass.numeros);
travail(temp);
return 3;
}
// thread utilisant une zone critique
unsigned long WINAPI DemarrerThread_zonecritique (void * Param)
{
char temp[2];
s_pass pass;
pass=*(s_pass * ) Param;
printf("thread %i : son message est \"%s\"\n", pass.numeros,pass.chaine);
sprintf(temp,"%i",pass.numeros);
EnterCriticalSection(&Sync);
travail(temp);
LeaveCriticalSection(&Sync);
return 3;
}
// theard utilisant les semaphores
unsigned long WINAPI DemarrerThread_semaphore (void * Param)
{
char temp[2];
s_pass pass;
pass=*(s_pass * ) Param;
printf("thread %i : son message est \"%s\"\n", pass.numeros,pass.chaine);
sprintf(temp,"%i",pass.numeros);
WaitForSingleObject(semp,INFINITE);
travail(temp);
ReleaseSemaphore(semp,1,NULL);
return 3;
}
// theard utilisant les mutex
unsigned long WINAPI DemarrerThread_mutex (void * Param)
{
char temp[2];
s_pass pass;
pass=*(s_pass * ) Param;
printf("thread %i : son message est \"%s\"\n", pass.numeros,pass.chaine);
sprintf(temp,"%i",pass.numeros);
WaitForSingleObject(mut,INFINITE);
travail(temp);
ReleaseMutex(mut);
return 3;
}
// le main
int main(int argc, char* argv[])
{
int i=0;
HANDLE hThread[20];
unsigned long ThreadId;
unsigned long lpExitCode;
s_pass pass[N];
for(i=0;i<N;i++)
{ pass[i].numeros=i+1;
sprintf(pass[i].chaine,"le %i est passe!",i+1);
}
test= new int;
//on modifie une variable dans un thread, et on fait du passage de paramatre
printf("main: valeur de test : %i\n",*test);
printf("main: creation de 1 thread (CreateThread)\n");
hThread [0] = CreateThread(NULL,NULL,DemarrerThread_test,(void *) &pass[0], NULL, &ThreadId);
printf("ID1 : %i\n",ThreadId);
printf("main le retour de GetExitCodeThread est %i \n",GetExitCodeThread(hThread[0],&lpExitCode) );
printf("main: retour : %i \n" ,lpExitCode);
printf("main: attente de fin du 1er (WaitForSingleObject)\n");
WaitForSingleObject(hThread[0],INFINITE);
printf("main le retour de GetExitCodeThread est %i \n",GetExitCodeThread(hThread[0],&lpExitCode) );
printf("main: retour : %i \n" ,lpExitCode);
printf("main: valeur de test : %i\n",*test);
// on utilise la fonction terminer un thread
printf("\n\n\nmain: creation de 1 thread (CreateThread)\n");
hThread [0] = CreateThread(NULL,NULL,DemarrerThread_base,(void *) &pass[0], NULL, &ThreadId);
printf("ID1 : %i\n",ThreadId);
printf("main le retour de GetExitCodeThread est %i \n",GetExitCodeThread(hThread[0],&lpExitCode) );
printf("main: retour : %i \n" ,lpExitCode);
printf("main: arret du thread (TerminateThread)\n");
TerminateThread(hThread [0], 10);
WaitForSingleObject(hThread[0],INFINITE);
printf("main le retour de GetExitCodeThread est %i \n",GetExitCodeThread(hThread[0],&lpExitCode) );
printf("main: retour : %i \n" ,lpExitCode);
// on attent la fin de 2 threads
printf("\n\n\nmain: creation de 2 threads (CreateThread)\n");
hThread [0] = CreateThread(NULL,NULL,DemarrerThread_base,(void *) &pass[0], NULL, &ThreadId);
printf("ID1 : %i\n",ThreadId);
hThread [1] = CreateThread(NULL,NULL,DemarrerThread_base,(void *) &pass[1],NULL, &ThreadId);
printf("ID2 : %i\n",ThreadId);
printf("main le retour de GetExitCodeThread du premier est %i \n",GetExitCodeThread(hThread[0],&lpExitCode) );
printf("main: retour : %i \n" ,lpExitCode);
printf("main le retour de GetExitCodeThread du deuxieme est %i \n",GetExitCodeThread(hThread[1],&lpExitCode) );
printf("main: retour : %i \n" ,lpExitCode);
printf("attente des 2 theards (WaitForMultipleObjects)\n");
WaitForMultipleObjects(2, hThread, TRUE, INFINITE);
printf("main le retour de GetExitCodeThread du premier est %i \n",GetExitCodeThread(hThread[0],&lpExitCode) );
printf("main: retour : %i \n" ,lpExitCode);
printf("main le retour de GetExitCodeThread du deuxieme est %i \n",GetExitCodeThread(hThread[1],&lpExitCode) );
printf("main: retour : %i \n" ,lpExitCode);
// on fait travailler N threads sur la meme variable (=normalement il y a un prableme d'ordre)
strcpy(texte,"debut :\n");
printf("\n\n\nmain: creation de %i threads (CreateThread) sans semaphore et sans zone critique\n",N);
for(i=0;i<N;i++)
{hThread [i] = CreateThread(NULL,NULL,DemarrerThread_travail,(void *) &pass[i], NULL, &ThreadId);
printf("ID%i : %i\n",i+1,ThreadId);
}
printf("attente de tout les threads (WaitForMultipleObjects)\n");
WaitForMultipleObjects(N, hThread, TRUE, INFINITE);
printf("resultat (normalement bordelique): \"%s\" \n",texte);
// on fait travailler N threads en utilisant une zone critique
strcpy(texte,"debut :\n");
printf("\n\n\ncreation de la szone critique(InitializeCriticalSection)\n");
InitializeCriticalSection(&Sync);
printf("main: creation de %i threads (CreateThread) avec zone critique\n",N);
for(i=0;i<N;i++)
{hThread [i] = CreateThread(NULL,NULL,DemarrerThread_zonecritique,(void *) &pass[i], NULL, &ThreadId);
printf("ID%i : %i\n",i+1,ThreadId);
}
printf("attente de tout les threads (WaitForMultipleObjects)\n");
WaitForMultipleObjects(N, hThread, TRUE, INFINITE);
printf("fermeture zone critique(DeleteCriticalSection)\n");
DeleteCriticalSection(&Sync);
printf("resultat : \"%s\" \n",texte);
// on fait travailler N theards en utilisant les semaphores
strcpy(texte,"debut :\n");
printf("\n\n\ncreation de la semaphore(CreateSemaphore)\n");
semp=CreateSemaphore(NULL,1,N,"truc");
printf("main: creation de %i threads (CreateThread) avec semaphore\n",N);
for(i=0;i<N;i++)
{hThread [i] = CreateThread(NULL,NULL,DemarrerThread_semaphore,(void *) &pass[i], NULL, &ThreadId);
printf("ID%i : %i\n",i+1,ThreadId);
}
printf("attente de tout les threads (WaitForMultipleObjects)\n");
WaitForMultipleObjects(N, hThread, TRUE, INFINITE);
printf("resultat : \"%s\" \n",texte);
printf("fermeture semaphore(CloseHandle)\n");
CloseHandle(semp);
// on fait travailler N theards en utilisant les mutex
strcpy(texte,"debut :\n");
printf("\n\n\ncreation de mutex(CreateMutex)\n");
mut=CreateMutex(NULL,FALSE,"mutex");
printf("main: creation de %i threads (CreateThread) avec mutex\n",N);
for(i=0;i<N;i++)
{hThread [i] = CreateThread(NULL,NULL,DemarrerThread_mutex,(void *) &pass[i], NULL, &ThreadId);
printf("ID%i : %i\n",i+1,ThreadId);
}
printf("attente de tout les threads (WaitForMultipleObjects)\n");
WaitForMultipleObjects(N, hThread, TRUE, INFINITE);
printf("resultat : \"%s\" \n",texte);
printf("fermeture mutex(CloseHandle)\n");
CloseHandle(mut);
// c'est la fin
printf("fin\n");
return 0;
}
Conclusion :
Vu que je n'avais pas trouvé d'exemple de ce genre sur le site, en voila un! j'espere qu'il vous aidera.
Commentaires
- Messages postés
- 1
- Date d'inscription
- mercredi 4 février 2009
- Statut
- Membre
- Dernière intervention
- 2 juillet 2010
-Il suffit de faire un simple test pour s'en rendre contre : par exemple en faisant deux boucle de calcul qui incrémentent un int 50000 fois chacune on ne va pas forcement tomber sur 100000 si l'on n'utilise pas de mutex. Car entre la lecture et la modification si ils sont concurrents il y a un calcul qui aura griller l'autre (en lisant la valeur ils vont tout deux prendre 85412 et au lieu de se retrouver avec 85414 on va avoir 85413!!!).
Voici le code utilisé (facile a adapté):
Mutex *mu;
int sum=0;
THR_RTYPE th1(void* param) {
for(int i=0; i<50000; i++) {
//mu->lock();
sum++;
//mu->unlock();
}
return 0;
}
THR_RTYPE th2(void* param) {
for(int i=0; i<50000; i++) {
//while( !mu->tryLock() ){}
sum++;
//mu->unlock();
}
return 0;
}
Au final le problème vient de la modification/lecture de la mémoire et non du calcul!
- Messages postés
- 33
- Date d'inscription
- mercredi 12 septembre 2007
- Statut
- Membre
- Dernière intervention
- 30 juin 2008
-Je comprends tout à fait la nécessité d'utiliser des mutex dans le cas d'un accès concurrent à un tableau par exemple, mais est ce utile si la ressource est un simple entier ?
Y'a t'il un risque de corruption de la ressource lorsqu'elle a une taille élémentaire ?
Merci d'avance
- Messages postés
- 56
- Date d'inscription
- samedi 28 juin 2003
- Statut
- Membre
- Dernière intervention
- 16 février 2006
-Un mutex peut être propriété d'un thread ou libre. Un sémaphore est un mutex qui peut être possédé par x personnes à la fois, on choisit x a la creation.
+++,
Lastpix'l
- Messages postés
- 15
- Date d'inscription
- jeudi 5 février 2004
- Statut
- Membre
- Dernière intervention
- 15 juin 2006
-Les mutex comme les zones critique sont des cas particulier des semaphores. Ils sont plus facile a utilisé c'est tout.
- Messages postés
- 45
- Date d'inscription
- samedi 31 mai 2003
- Statut
- Membre
- Dernière intervention
- 22 février 2006
-Vous n'êtes pas encore membre ?
inscrivez-vous, c'est gratuit et ça prend moins d'une minute !
Les membres obtiennent plus de réponses que les utilisateurs anonymes.
Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.
Le fait d'être membre vous permet d'avoir des options supplémentaires.