THREAD, SEMAPHORE, ZONE CRITIQUE ET MUTEX WINDOWS

// 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;
}