Salut voilà j'ai passé du temps à comprendre les moniteurs et les threads, mais la je bloque...
En faite je dois réaliser un parking avec n places et x voitures (x>n). Si toutes les places sont prise les voitures doivent attendre qu'une place se libère, au bout de x seconde une voiture quitte son stationnement, une autre peut alors entrer dans le parking et s'y garer .

Mon problème est que même s'il n y a plus de place dans le parking les voitures entrent...

Voici mon prog.
Code c : 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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
 
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <pthread.h>
 
#define NOMBRES_DE_PLACES 5	//Nombre de places de parking.
#define NOMBRES_DE_VOITURES 10  //Nombre de voitures.
 
 
typedef struct
{
	pthread_cond_t vide;
	pthread_cond_t plein; 
	pthread_mutex_t mutex; 
 
	int nombres_de_places ;		//nombres de places prises
	int nombres_de_voiture ;	//nombres de voitures dans le parking
 
 
} MUTEX_FG;
 
 
 
typedef struct
{
	int id_voiture;		 	// id de la voiture
	int duree_attente; 		//temps de stationement de chaque voitures
 
	MUTEX_FG *mutex;		// toutes les voiture partagent le meme verrou
 
} VOITURE;
 
 
 
/****************************************INITIALISATION DE LA STRUCTURE********************************************/
/******************************************************************************************************************/
MUTEX_FG *fg_init(MUTEX_FG *m)
{
 
	pthread_mutex_init(&m->mutex, NULL);
	pthread_cond_init(&m->vide, NULL);
	pthread_cond_init(&m->plein, NULL);
 
	m->nombres_de_places=NOMBRES_DE_PLACES;
	m->nombres_de_voiture= 0;
}
 
 
 
/***************************************PROCEDURE ENTREE D UNE VOITURE********************************************/
/*****************************************************************************************************************/
void entree_voiture(MUTEX_FG *m)
{
	pthread_mutex_lock(&m->mutex);
 
		if(m->nombres_de_voiture==NOMBRES_DE_PLACES)	
		{
 
			pthread_cond_broadcast(&m->plein);;//les places de parking sont plein.
		}
 
		while(m->nombres_de_places<=0)
		{
			pthread_cond_wait(&m->vide, &m->mutex);// attend qu'une place soit disponible
		}
 
	m->nombres_de_voiture++;// compte le nombre de voiture garer
 
 
	m->nombres_de_places--;	// une place est occuppee par une voiture
 
 
 
	pthread_mutex_unlock(&m->mutex);
}
 
 
 
/***************************************PROCEDURE SORTIE D UNE VOITURE********************************************/
/*****************************************************************************************************************/
void sortie_voiture(MUTEX_FG *m)
{
	pthread_mutex_lock(&m->mutex);
 
	m->nombres_de_voiture--;	// compte le nombre de voiture garer
 
 
	m->nombres_de_places++;		// signale qu'une place est disponible
	printf("\n\tCOMPTEUR PLACE: %d places libres.\n",m->nombres_de_places);
 
	pthread_cond_broadcast(&m->vide);
	pthread_mutex_unlock(&m->mutex);	
}
 
 
 
/*************************************THREAD ENTREE/SORTIE D UNE VOITURE*************************************************/
/************************************************************************************************************************/
void *entree_sortie(void *voidparam )
{
	VOITURE *v= (VOITURE *) voidparam;
 
	// se gare et attend
	printf("\tLa voiture %d entre dans le parking et se gare pour %d secondes, attente %ds\n", v->id_voiture, v->duree_attente, v->duree_attente);
	entree_voiture(v->mutex);//appel de la procedure d entre dans le parking d une voiture
	sleep(v->duree_attente); //La voiture reste gare pour x secondes
 
	// repart
	printf("\nLa voiture %d quitte sa place, une nouvelle voiture peut entrer.",  v->id_voiture);
	sortie_voiture(v->mutex);//appel de la procedure de sortie du parking d une voiture
 
	pthread_exit(NULL);
	return NULL;
}
 
 
 
/*************************************PROGRAMME PRINCIPAL*********************************************************/
/*****************************************************************************************************************/
int main(void)
{
	VOITURE v[NOMBRES_DE_VOITURES];
	pthread_t tid[NOMBRES_DE_VOITURES];
	MUTEX_FG verrou;
 
	int i;
 
	srand(time(NULL));
 
	fg_init(&verrou);// creer le verrou	
 
 
	printf("\n\n\t********** NOMBRES DE VOITURES : %d voiture || NOMBRES DE PLACES: %d places **********\n\n", NOMBRES_DE_VOITURES, NOMBRES_DE_PLACES);
 
	// creation du stationnement des voitures
 
		for(i= 0; i < NOMBRES_DE_VOITURES; i++)
		{
			// attendre, toutes les voitures ne se presente pas en meme temps
			sleep(rand() % 2);
 
				v[i].mutex= &verrou;	// toutes les voitures partagent le meme verrou
				v[i].id_voiture=i;
				v[i].duree_attente= 3 + rand() % 5; // entre 3 et 7 secondes pour rester statione 
 
				pthread_create(&tid[i], NULL, entree_sortie, &v[i]);		
		}
 
		for(i= 0; i <NOMBRES_DE_VOITURES; i++)
			pthread_join(tid[i], NULL);
}