Discussion :

[sidb10]

Bonjour à tous,

J'essaye de réaliser un code réalisant le fameux diner des philosophe avec des threads sous Windows.

Mon problème est le suivant, je suis coincé avec ce code, et je n'arrive pas à comprendre d'où viens mon problème, le code n'affiche rien...

Si quelqu'un pourrait me filer un coup de main, ou m'orienter ce serait super sympa.

Merci d'avance.

Code:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
	#include <iostream>
	#include <fstream>
	#include <windows.h>
	#include <vector>
	#include <mutex>
	using namespace std;
 
 
	//bool *forks = NULL ;
 
	bool forks[5]={true,true,true,true,true};
 
	//mutex m;
 
	DWORD WINAPI T_Philo(LPVOID lpParam)
	{
		int n;
		n=*((int*)lpParam);
 
		cout<<"Philo "<<n+1<<" is thinking."<<endl;
		Sleep(500);
 
		while (forks[n]==false || forks[(n+1)%5]==false){
 
			}
 
		if (forks[n]==true && forks[(n+1)%5]==true){
 
			forks[n]=false;
			forks[(n+1)%5]=false;
			cout<<"Philo "<<n+1<<" is eating. "<<endl;
			Sleep(200);
			forks[n]=true;
			forks[(n+1)%5]=true;
 
		}
 
 
		return 0;
	}
 
 
 
 
 
	int main()
	{
 
 
 
		HANDLE th[5];
		DWORD threadID[5];
	for (int i=0;i<5;i++){
 
		th[i]=CreateThread(NULL,0,T_Philo[i],(LPVOID)i,0,&threadID[i]);
		WaitForSingleObject(th[i],INFINITE);
	}
 
	}

[Médinoc]

Bonjour,

1. T_Philo est une fonction, pas un tableau de fonctions. Enlève le [i] dans ton appel à CreateThread().
2. Tu dois mettre les appels à WaitForSingleObject() dans une seconde boucle, car là, tu crées et attends un thread à la fois...
3. Les manipulations que tu fais sur les booléens sont tout sauf thread-safe. Ton tableau de fourchettes devrait être un tableau de mutexes, et non pas un tableau de booléens.

[pjlan]

Je pense que tu dois mettre &i aussi (LPVOID est un bête typedef sur void*)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

CreateThread(NULL,0,T_Philo[i],&i,0,&threadID[i]);

[Médinoc]

En théorie, il faudrait forcément passer un pointeur (et alors s'inquiéter des considérations de durée de vie de la variable et du thread). En pratique, pour cet exercice tu peux laisser le cast en void*, mais remplacer le n=*((int*)lpParam); par n = (int)lpParam;. Peut-être passer par un cast en INT_PTR pour faire plus propre:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
#include <windows.h>
#include <iostream>
 
HANDLE g_forks[5]={NULL, NULL, NULL, NULL, NULL};
 
DWORD WINAPI T_Philo(LPVOID lpParam)
{
	int n = (int)(INT_PTR)lpParam;
 
	std::cout<<"Philo "<<n+1<<" is thinking."<<std::endl;
	Sleep(500);
 
	//Note: Ceci est une méthode qui marche, parce que Windows résout le problème pour toi.
	//Mais ce n'est pas le but de l'exercice: Le but de l'exercice,
	//c'est de réussir à le faire sans t'empêtrer SANS utiliser WaitForMultipleObjects.
 
	//Attempt to grab both forks simultaneously
	HANDLE myForks[2] = { g_forks[n], g_forks[(n+1)%5] };
	DWORD waited = WaitForMultipleObjects(2, myForks, TRUE, INFINITE);
	if(waited == WAIT_OBJECT_0) {
		std::cout<<"Philo "<<n+1<<" is eating. "<<std::endl;
		Sleep(200);
		ReleaseMutex(myForks[0]);
		ReleaseMutex(myForks[1]);
	}
 
	//Aussi, est-ce normal que chaque philosophe ne mange qu'une seule fois? Normalement on fait ça en boucle
	//(et comme condition d'arrêt, "ça fait dix minutes que le programme tourne" peut suffire)
 
	return 0;
}
 
int main()
{
	HANDLE th[5];
	DWORD threadID[5];
 
	//Create the forks
	for (int i=0;i<5;i++) {
		g_forks[i] = CreateMutex(NULL, FALSE, NULL);
	}
 
	//Spawn the philosophers
	for (int i=0;i<5;i++) {
		th[i]=CreateThread(NULL, 0, T_Philo, (LPVOID)(INT_PTR)i, 0, &threadID[i]);
	}
 
	//Wait for the end of the meal, clean up the dishes
	for (int i=0;i<5;i++) {
		WaitForSingleObject(th[i],INFINITE);
		CloseHandle(th[i]), th[i]=NULL;
	}
 
	//Clean up the forks too.
	for (int i=0;i<5;i++) {
		CloseHandle(g_forks[i]), g_forks[i]=NULL;
	}
	return 0;
}