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.
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.