problèmes avec les Mutex

Version imprimable

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:

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

29/03/2014, 15h17
Trademark

Ton programme marche bien, c'est juste que tu affiches qu'une voiture est entrée avant qu'elle soit effectivement entrée...

Sinon tu peux te passer des variables nombres_de_voiture et pthread_cond_t plein;.

Merci :mouarf:

Voici mon premier prog corrigé.

Code:

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
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
 
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <pthread.h>
 
#define NOMBRES_DE_PLACES 25	//Nombre de places de parking.
#define NOMBRES_DE_VOITURES 40  //Nombre de voitures.
 
#define NOMBRES_ENTREES 3	//Nombres d entrees dans le parking.
#define NOMBRES_SORTIES 2	//Nomres de sortie du parking.
 
#define LIBRE 1 		// il reste des places.
#define REMPLIS 0 		//parking remplis.
 
 
typedef struct
{
 
	int nombres_de_places ;
	pthread_mutex_t places_mutex;
 
	int nombres_de_voiture ;
	pthread_mutex_t voiture_mutex;
 
	int nombres_entrees ;
	//pthread_mutex_t entrees_mutex;
 
	int nombres_sorties ;
	//pthread_mutex_t sorties_mutex;
 
	int statu ;
	pthread_cond_t statu_cond;
 
} MUTEX_FG;
 
 
 
typedef struct
{
	char id_voiture;           // id de la voiture.
	int temps_stationement ;  //temps du stationement d une voiture.
 
	MUTEX_FG *mutex;	 // toutes les voiture partagent le meme verrou.
 
	int duree_attente; 
 
} VOITURE;
 
 
 
/****************************************INITIALISATION DE LA STRUCTURE********************************************/
/******************************************************************************************************************/
MUTEX_FG *fg_init(MUTEX_FG *m)
{
	pthread_mutex_init(&m->places_mutex, NULL);
	pthread_mutex_init(&m->voiture_mutex, NULL);
	pthread_cond_init(&m->statu_cond, NULL);
 
	m->nombres_de_places= NOMBRES_DE_PLACES;
	m->nombres_de_voiture= NOMBRES_DE_VOITURES;
 
	m->nombres_entrees= NOMBRES_ENTREES;
	m->nombres_sorties= NOMBRES_SORTIES;
 
	m->statu= LIBRE;
 
	return m;
}
 
 
 
/***************************************PROCEDURE ENTREE D UNE VOITURE********************************************/
/*****************************************************************************************************************/
void entree_voiture(MUTEX_FG *m)
{
 
	pthread_mutex_lock(&m->places_mutex);	
	pthread_mutex_lock(&m->voiture_mutex);
	printf("%d places restantes\n", m->nombres_de_places);
	while(m->statu!=REMPLIS)
		pthread_cond_wait(&m->statu_cond, &m->voiture_mutex);	// attend qu'une place soit disponible
 
	m->nombres_de_voiture--;
	m->nombres_de_places--; // une place est occuper par une voiture
 
	pthread_mutex_unlock(&m->places_mutex);
	pthread_mutex_unlock(&m->voiture_mutex);
}
 
 
 
/***************************************PROCEDURE SORTIE D UNE VOITURE********************************************/
/*****************************************************************************************************************/
void sortie_voiture(MUTEX_FG *m)
{
	pthread_mutex_lock(&m->places_mutex);	
	pthread_mutex_lock(&m->voiture_mutex);
 
	m->nombres_de_places++;	// signale qu'une place est disponible
 
	pthread_mutex_unlock(&m->places_mutex);
	pthread_mutex_unlock(&m->voiture_mutex);
	pthread_cond_broadcast(&m->statu_cond);
 
}
 
 
 
/*************************************THREAD ENTREE/SORTIE D UNE VOITURE*************************************************/
/************************************************************************************************************************/
void *entree_sortie(void *voidparam )
{
	VOITURE *v= (VOITURE *) voidparam;
 
	entree_voiture(v->mutex);
	printf("La voiture %d entre dans le parking...\n", v->id_voiture);
 
	// la voiture se gare
	v->duree_attente= 10;
	printf("La voiture %d se gare pour %d secondes, attente %ds\n", v->id_voiture, v->duree_attente, v->duree_attente);
	sleep(v->duree_attente);
 
	// repart
	printf("    La voiture %d sort du parking\n", v->id_voiture);
	sortie_voiture(v->mutex);
 
 
	pthread_exit(NULL);
	return NULL;
 
}
 
 
 
/*************************************PROGRAMME PRINCIPAL*********************************************************/
/*****************************************************************************************************************/
int main(void)
{
	VOITURE p[NOMBRES_DE_VOITURES];
	pthread_t tid[NOMBRES_DE_VOITURES];
	MUTEX_FG v;
 
	int t;
	//int code;
	int i;
 
	srand(time(NULL));
 
	// creer le verrou
	fg_init(&v);
 
 
	//printf("douche : %d voitures, %d places\n", v->nombres_de_voiture, v->nombres_de_places);
 
	// creation des voiture entree/sortie
 
	for(i= 0; i < NOMBRES_DE_VOITURES; i++)
	{
		// attendre, toutes les voitures ne se presentent pas en meme temps
		sleep(rand() % 2);
 
			p[i].mutex= &v;	// toutes les voitures partagent le meme verrou
			p[i].id_voiture=i;
 
			pthread_create(&tid[i], NULL, entree_sortie, &p[i]);
		        pthread_join(tid[i],NULL);
	}
}