exercice pthread cond

Version imprimable

Yo!
Je suis entrain de réviser et je n'arrive pas à refaire un petit exo.

J'ai une boite de message qui contient un seul message.
2pools de threads:
-consommateur qui récupère le message si la boite n'est pas vide.
-producteur qui remet un message si la boite est vide.

Le but est d'utiliser les conditions pour que ce soit optimisé.
Mon problème est qu'il ne se passe rien dans mon code.
Je pense que c'est normal, vu que les signaux pour réveiller mes threads ne partent jamais, cependant je ne sais pas qu'elle la meilleure solution pour régler le problème...
Un if pour vérifier l'état dde ma boite ?
Une boucle sur pthread_cond_wait tant que la boite est vide ou non ?
Voici mon code:

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
    #include <pthread.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
 
    char msg[50] = "message plein";
    char msg2[50] = "nouveau message";
    char msg3[50] = "";
    pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
    pthread_cond_t cond_prod = PTHREAD_COND_INITIALIZER;
    pthread_cond_t cond_conso = PTHREAD_COND_INITIALIZER;
 
    void *routine_producteur(void *arg){
            while(1){
                    pthread_mutex_trylock(&mutex);
                    pthread_cond_wait(&cond_prod,&mutex);
                            printf("Le thread producteur a ete reveille");
                            printf("La boite contient : %s",msg);                  
                    memcpy(&msg,&msg2,strlen(msg2)+1);
                            printf("un message a ete depose! \n");
                            printf("La boite contient : %s",msg);
                    pthread_cond_signal(&cond_conso);
                    pthread_mutex_unlock(&mutex);
            }
            return NULL;
    }
 
    void *routine_consommateur(void *arg){
            while(1){
                    pthread_mutex_trylock(&mutex);
                    pthread_cond_wait(&cond_conso,&mutex);
                            printf("Le thread consommateur a ete reveille");
                            printf("La boite contient : %s",msg);                  
                    memcpy(&msg,&msg3,strlen(msg3)+1);
                            printf("un message a ete retire! \n");
                            printf("La boite contient : %s",msg);
                    pthread_cond_signal(&cond_prod);
                    pthread_mutex_unlock(&mutex);
            }
            return NULL;
    }
 
    int main(void){
            pthread_t conso_t[4];
            pthread_t prod_t[4];
            int i;
            for(i=0; i<=3; i++){
                    pthread_create(&conso_t[i], NULL, routine_consommateur, NULL);                 
                    pthread_create(&prod_t[i],NULL,routine_producteur, NULL);
            }
 
            for(i=0; i<=3; i++){
                    pthread_join(conso_t[i], NULL);
                    pthread_join(prod_t[i],NULL);
            }
 
            return 0;
    }

17/06/2013, 04h08
kwariz

Bonjour,

bon je suis pas un pro des pthreads ... mais il me semble que le mutex doit être locké avant un cond wait ... le try est de trop. Puis ensuite tout le monde attend sur les conditions ... donc dans le main il faudrait signaler aux producteurs qu'il peuvent y aller.
18/06/2013, 10h18
deletme

Salut,

Il ne devrait pas y avoir une initialisation de tes sémaphores dans ton main ?

Code:

int pthread_mutex_init (pthread_mutex_t * mutex , pthread_mutexattr_t * attr );

deletMe

@deletme
Il les a initialisés statiquement :

Code:

1
2
3
    pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
    pthread_cond_t cond_prod = PTHREAD_COND_INITIALIZER;
    pthread_cond_t cond_conso = PTHREAD_COND_INITIALIZER;

18/06/2013, 13h14
deletme

Ok je ne connaissais pas cette façon de faire, merci ^^

C'est bon, j'ai modifié le code pour rendre ok.

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
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
char msg[50] = "message";
char msg2[50] = "nouveau message";
char msg3[50] = " ";
 
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond_prod = PTHREAD_COND_INITIALIZER;
pthread_cond_t cond_conso = PTHREAD_COND_INITIALIZER;
 
void *routine_producteur(void *arg){
	int i = (int *)arg;
	while(1){
		pthread_mutex_lock(&mutex);
		while (msg[0] != ' '){
			pthread_cond_wait(&cond_prod,&mutex);
		}
		printf("\n\n\n\n\n Le thread producteur a ete reveille");
		printf("La boite contient : %s",msg);			
		memcpy(&msg,&msg2,strlen(msg2)+1);
			printf("un message a ete depose! par le producteur %d\n",i);
			printf("La boite contient : %s",msg);
		pthread_cond_signal(&cond_conso);
		pthread_mutex_unlock(&mutex);
	}
	return NULL;
}
 
void *routine_consommateur(void *arg){
	int i = (int *)arg;
	while(1){
		pthread_mutex_lock(&mutex);
		while(msg[0] == ' '){
			pthread_cond_wait(&cond_conso,&mutex);
		}
			printf("\n\n\n\n\nLe thread consommateur a ete reveille \n");
			printf("La boite contient : %s \n",msg);			
		memcpy(&msg,&msg3,strlen(msg3)+1);
			printf("un message a ete retire par le consommateur %d! \n",i);
			printf("La boite contient : %s \n",msg);
		pthread_cond_signal(&cond_prod);
		pthread_mutex_unlock(&mutex);
	}
	return NULL;
}
 
int main(void){
	pthread_t conso_t[4];
	pthread_t prod_t[4];
	int i;
	for(i=0; i<=3; i++){
		pthread_create(&conso_t[i], NULL, routine_consommateur, (void*)i);			
		pthread_create(&prod_t[i],NULL,routine_producteur,  (void*)i);
	}
 
	for(i=0; i<=3; i++){
		pthread_join(conso_t[i], NULL);	
		pthread_join(prod_t[i],NULL);
	}
 
	printf(" Message => %s \n",msg);
	return 0;
}