Thread, semaphore, zone critique et mutex windows

Soyez le premier à donner votre avis sur cette source.

Vue 38 927 fois - Téléchargée 1 169 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

Semaphore cpp
Semaphore c++ - Meilleures réponses
C++ semaphore - Meilleures réponses
Thread & Semaphore ✓ - Forum - C / C++ / C++.NET
C# / .NET : Mecanisme de synchronisation de thread - monitor, mutex, semaphore, resetevent - CodeS - Guide
Parrallelisme / Semaphores / Mutex / Section Critique ✓ - Forum - Visual Basic
Mutex thread ✓ - Forum - C / C++ / C++.NET
Exception in thread "awt-eventqueue-0" java.lang.illegalargumentexception: adding a window to a container - Forum - Java

Ajouter un commentaire

Commentaires

Signaler

Neotuxxx

Messages postés: 1
Date d'inscription: mercredi 4 février 2009
Statut: Membre
Dernière intervention: 2 juillet 2010

2 juil. 2010 à 16:45

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

shuttleur

Messages postés: 33
Date d'inscription: mercredi 12 septembre 2007
Statut: Membre
Dernière intervention: 30 juin 2008

12 août 2008 à 12:28

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

lastpixl

Messages postés: 56
Date d'inscription: samedi 28 juin 2003
Statut: Membre
Dernière intervention: 16 février 2006

2 avril 2004 à 21:44

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

xian240482

Messages postés: 15
Date d'inscription: jeudi 5 février 2004
Statut: Membre
Dernière intervention: 15 juin 2006

9 mars 2004 à 11:29

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

cs_yAAm

Messages postés: 45
Date d'inscription: samedi 31 mai 2003
Statut: Membre
Dernière intervention: 22 février 2006

5 mars 2004 à 11:11

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.

Thread, semaphore, zone critique et mutex windows

Description

Source / Exemple :

Conclusion :

Codes Sources

A voir également

Commentaires

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Du même auteur (xian240482)

Fichier binaire fread fwrite

Objet client serveur tcp / ip windows miltitache

Pile class template operator

Source / Exemple :

Conclusion :

A voir également

Vous n'êtes pas encore membre ? inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Du même auteur (xian240482)

Fichier binaire fread fwrite

Objet client serveur tcp / ip windows miltitache

Pile class template operator

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !