1. Accueil
  2. C / C++ / C++.NET
  3. Sources C / C++ / C++.NET
  4. Sources Système
  5. Thread, semaphore, zone critique et mutex windows

Thread, semaphore, zone critique et mutex windows

Soyez le premier à donner votre avis sur cette source.

Vue 39 045 fois - Téléchargée 1 170 fois

Télécharger le projet
Commenter

Description

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);


    	
  • test=1;

	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);


        
  • test=1;

	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


    	
  • test=0;

	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.
Télécharger le projet

Codes Sources

A voir également

Ajouter un commentaire Commentaires
Signaler
Messages postés
1
Date d'inscription
mercredi 4 février 2009
Statut
Membre
Dernière intervention
2 juillet 2010
Même pour un simple int global les mutex sont nécessaires!
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!
Signaler
Messages postés
33
Date d'inscription
mercredi 12 septembre 2007
Statut
Membre
Dernière intervention
30 juin 2008
Salut à tous

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
Signaler
Messages postés
56
Date d'inscription
samedi 28 juin 2003
Statut
Membre
Dernière intervention
16 février 2006
Les sémaphores ont un counter, pas les mutex.
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
Signaler
Messages postés
15
Date d'inscription
jeudi 5 février 2004
Statut
Membre
Dernière intervention
15 juin 2006
La difference entre les semaphores et les mutex? aucune!
Les mutex comme les zones critique sont des cas particulier des semaphores. Ils sont plus facile a utilisé c'est tout.
Signaler
Messages postés
45
Date d'inscription
samedi 31 mai 2003
Statut
Membre
Dernière intervention
22 février 2006
Les mutex sont des objet permettant de synchroniser les threads, par exemple pour laisser un acces exclusif a chaque tread qui en est proprietaire ainsi que de booster la priorité de celui-ci et ... si j'ai bien compris, mais alors quelle est la difference avec une semaphore ?????
Afficher les 9 commentaires
S'inscrire maintenant

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.

Du même auteur (xian240482)