Aide pthread utilisation

Bonsoir,

je suis actuellement en train de réaliser un projet qui consiste à simuler l'activité de plusieurs caisses dans un magasin.
J'ai créé trois fonctions qui calculent les articles du client et je souhaiterais les exécuter en même temps.

Je sais utiliser les pthreads si on considère qu'il n'y a qu'une seule caisse mais je bloque quand il s'agit de le faire sur plusieurs caisses, et donc j'ai besoin de votre aide svp.

Je pensais faire un tableau de thread :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 int main(){ pthread_t thread[nombreDeCaisse]; int i; for(i=0; i<nombreDeCaisse; i++){ pthread_create(thread[i], NULL, fonction1, NULL); pthread_create(thread[i], NULL, fonction2, NULL); pthread_create(thread[i], NULL, fonction3, NULL); } for(i=0; i<nombreDeCaisse; i++){ pthread_join(thread[i],NULL); } return 0; }
Je ne sais pas si c'est comme ça que l'on fait, merci de bien vouloir m'aider.

Merci d'avance.

Tu pourrais appeler 3 threads avec la même fonction. Par-contre il faudra que tes threads quittent par eux-même sinon tu vas te retrouver avec une "boucle" infinie. Et pourquoi ne pas virer un thread et faire son traitement dans ton thread principal ? Tu pourras toujours join tes autres threads quand il aura fini.

Merci ça marche beaucoup mieux en utilisant une seule fonction, par contre la quand je fais des printf pour voir ce qui se passe, je me retrouve avec des doublons :/

C'est-à-dire ?

Essaie d'afficher une information unique à chaque thread au début de chaque ligne (son pid?)

@leternel: les threads ne sont pas censés être des processus léger sous linux et donc avoir le même pid que leur processus parent ?

@mohaskh: il te suffit de passer une info différente à chaque thread si tu veux voir lequel est lequel (un p'tit cast en void* et le tour est joué).

Bonjour,

merci de votre réponse. J'ai essayé de casté en (void*) mais j'ai toujours le même soucis.
Voila ce que j'ai fais pour le moment.

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
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <math.h>
#include <sys/time.h>
#include <unistd.h>
#include <pthread.h>
#include <semaphore.h>
#include <unistd.h>
 
#define MAXCLIENT 50 // Maximum de client pouvant entrée
#define NBCLIENT 100 // Nombre de client considéré
#define TAMPONCHARIOT 20 // Tampon chariot
 
int PORTIQUE = 0; // nombre d'entrée et sortie
 
sem_t semportique, semAcces, semSortie, semcaisse[4];
pthread_t thclient[NBCLIENT], thcaisse[4];
 
typedef struct Client{ // Structure client
    int num;
    int *chariot;
    double ticket[3];
    int caisse;
    int entree;
} Client;
 
typedef struct Caisse{ // Structure caisse
    int *produit;
    int nbClient;
} Caisse;
 
Client *client;
Caisse caisse[4]; // on considere 4 caisses
 
 
void InitClient(){ // Fonction initialisation des clients
    int i;
    for(i=0; i<MAXCLIENT; i++){
        client[i].num = i;
        client[i].ticket[0] = 0;
        client[i].ticket[1] = 0;
        client[i].ticket[2] = 0;
        client[i].chariot = calloc(TAMPONCHARIOT,sizeof(int));
    }
}
 
void InitCaisse(){ // Fonction initialisation de 4 caisses
    int i;
    for(i=0; i<4; i++){
        caisse[i].produit = calloc(TAMPONCHARIOT,sizeof(int));
        caisse[i].nbClient = 0;
    }
}
 
void remplirChariot(int num){ // Fonction remplir le chariot aléatoirement
    int i;
    int nbProduit;
 
    for(i=0; i<TAMPONCHARIOT; i++){
        nbProduit = ((int) rand()%5 + 1);
        client[num].chariot[i] = nbProduit;
    }
}
 
void deposeProduit(int num, int numcaisse){ // Fonction depose produit sur la caisse
    int i;
    for(i=0; i<TAMPONCHARIOT; i++){
        caisse[numcaisse].produit[i] = client[num].chariot[i];
    }
}
 
void *moyenneArithmetique(void *data){ // Fonction moyenne arithmetique des produits
    int j;
    int *num = (int*) data;
    int numcaisse = client[*num].caisse;
 
    for(j=0; j<TAMPONCHARIOT; j++){
        client[*num].ticket[0] += caisse[numcaisse].produit[j];
    }
 
    client[*num].ticket[0] = client[*num].ticket[0]/TAMPONCHARIOT;
}
 
void *moyenneQuadratique(void *data){ // Fonction moyenne quadratique des produits
    int j;
    int *num = (int*) data;
    int numcaisse = client[*num].caisse;
 
    for(j=0; j<TAMPONCHARIOT; j++){
        client[*num].ticket[1] += caisse[numcaisse].produit[j]*caisse[numcaisse].produit[j];
    }
 
    client[*num].ticket[1] = sqrt(client[*num].ticket[1]/TAMPONCHARIOT);
}
 
void *sommeCubique(void *data){ // Fonction somme cubique des produits
    int j;
    int *num = (int*) data;
    int numcaisse = client[*num].caisse;
 
    for(j=0; j<TAMPONCHARIOT; j++){
        client[*num].ticket[2] += caisse[numcaisse].produit[j]*caisse[numcaisse].produit[j]*caisse[numcaisse].produit[j];
    }
}
 
int caisseCourte(){ // Fonction calcul caisse la moins longue
    int i;
    int num = 0;
    int min = caisse[0].nbClient;
 
    for(i=1; i<4; i++){
        if(caisse[i].nbClient<min){
            min = caisse[i].nbClient;
            num = i;
        }
    }
 
    caisse[num].nbClient++;
 
    return num;
}
 
void sortieClient(int num){ // Fonction sortie des clients
    int numcaisse = client[num].caisse;
    caisse[numcaisse].nbClient--;
}
 
void activiteCaisse(int client){ // Fonction activité de la caisse calculant les produits
    int i;
    pthread_t thread1,thread2,thread3;
 
    pthread_create (&thread1, NULL, moyenneArithmetique, &client);
    pthread_create (&thread2, NULL, moyenneQuadratique, &client);
    pthread_create (&thread3, NULL, sommeCubique, &client);
 
    pthread_join(thread1,NULL);
    pthread_join(thread2,NULL);
    pthread_join(thread3,NULL);
}
 
void *activiteClient(void *data){ // Fonction activité des clients
 
    int *num = (int*) data;
    int numcaisse;
 
    sem_wait(&semportique);
    if(!client[*num].entree){
        PORTIQUE++;
        printf("client %d entré\n",client[*num].num);
        client[*num].entree = 1;
 
        remplirChariot(client[*num].num);
        printf("client %d a rempli son chariot\n",client[*num].num);
 
        sem_wait(&semAcces);
        numcaisse = caisseCourte();
        client[*num].caisse = numcaisse;
        printf("client %d choisi caisse numero %d\n",client[*num].num,numcaisse);
        sem_post(&semAcces);
 
        deposeProduit(client[*num].num, numcaisse);
 
        sem_wait(&semcaisse[numcaisse]);
        activiteCaisse(client[*num].num);
        sem_post(&semcaisse[numcaisse]);
 
        sem_wait(&semAcces);
        sortieClient(numcaisse);
        PORTIQUE--;
 
        printf("client %d = (ticket(%f,%f,%f) \n",client[*num].num, client[*num].ticket[0], client[*num].ticket[1], client[*num].ticket[2]);
        sem_post(&semAcces);
    }
    sem_post(&semportique);
}
 
 
int main(){
    int i,j;
 
    sem_init(&semportique,0,MAXCLIENT);
    sem_init(&semAcces,0,1);
 
    for(i=0; i<4; i++){
        sem_init(&semcaisse[i],0,MAXCLIENT/4);
    }
 
    client = malloc(MAXCLIENT*sizeof(Client));
 
    srand(time(NULL));
 
    InitClient();
    InitCaisse();
 
    for(i=0; i<NBCLIENT; i++){
        pthread_create(&thclient[i],NULL,activiteClient,(void*)&i);
 
    }
 
    for(i=0; i<NBCLIENT; i++){
        pthread_join(thclient[i],NULL);
    }
 
    -
 
    return 0;
}

Problème très simple, regardons ce qui se passe :

- i vaut 0, on l'envoie son adresse dans le thread.
- on incrémente i
- i vaut 1, on envoie son adresse dans un autre thread
- ...

Tu vois mieux le problème ? N'envoie pas son adresse, contente-toi d'envoyer i, pas son adresse :
Code:

1 2 3 4 5 6 void *activiteClient(void *data){ // Fonction activité des clients int num = (int) data; ... pthread_create(&thclient[i],NULL,activiteClient,(void*)i);

Merci beaucoup, problème résolu ça fonctionne tu es un genie imperio ;)

Oula non ! J'essaie juste de comprends ce que je fais, ce qui est déjà pas mal.

PS1: Laisse ton code pour les autres qui auraient un problème similaire au tien.
PS2: Passe le sujet en résolu si c'est bon pour toi.