Blocage synchronisation threads (pthread Windows)
Bonjour à tous,
Je me permets de vous exposer mon problème en espérant que vous pourrez m'aider à comprendre pourquoi il se passe ce qu'il se passe lors de l'exécution de mon programme.
Mon objectif est le suivant :
Création de deux threads (task_timer et task_read)
Les tâches doivent écrire tour à tour leur message à savoir :
Tache 1
Tache 2
Tache 1
Tache 2
...
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
|
static void* task_timer(void* arg);
static void* task_read(void* p);
struct strShared{
pthread_mutex_t mut;
pthread_mutex_t mut2;
pthread_cond_t synchro;
pthread_cond_t synchro2;
};
struct strTimer{
int wt;
strShared* psh;
};
static void* task_timer(void* p){
time_t echeance;
strTimer* timer;
int time_waiting = 1000;
time_t now;
if(p != NULL){
timer = p;
time_waiting = timer->wt; //ms
echeance = time (NULL) + TIME_OF_THREAD;
while (1)
{
pthread_mutex_lock(&timer->psh->mut);
printf("Tache 1\n");
pthread_cond_signal(&timer->psh->synchro);
pthread_cond_wait(&timer->psh->synchro2, &timer->psh->mut);
pthread_mutex_unlock(&timer->psh->mut);
}
}
return NULL;
}
static void* task_read(void* p){
strTimer* timer;
if(p != NULL){
timer = p;
while(1){
pthread_mutex_lock(&timer->psh->mut);
pthread_cond_wait(&timer->psh->synchro, &timer->psh->mut);
printf("Tache 2\n");
pthread_cond_signal(&timer->psh->synchro2);
pthread_mutex_unlock(&timer->psh->mut);
}
}
return NULL;
}
int main (void)
{
pthread_t ttimer;
pthread_t tread;
/* TIMER */
strTimer timer;
strShared shtimer;
shtimer.mut = PTHREAD_MUTEX_INITIALIZER;
shtimer.mut2 = PTHREAD_MUTEX_INITIALIZER;
shtimer.synchro = PTHREAD_COND_INITIALIZER;
shtimer.synchro2 = PTHREAD_COND_INITIALIZER;
timer.psh = &shtimer;
timer.wt = 1000;
/* Threads */
pthread_create(&ttimer, NULL, task_timer, &timer);
pthread_create(&tread, NULL, task_read, &timer);
pthread_join(ttimer,NULL);
pthread_join(tread,NULL);
return 0;
} |
Selon moi ceci est la bonne manière de faire en revanche cela ne fonctionne pas je pense donc que mon raisonnement est erroné. Selon moi, mon programme s'exécute de la manière suivante :
1) Les deux tâches une fois crées s'exécutent en parallèle.
2) Task_read prends le mutex mut, attends le signal synchro et relâche le mutex mut car le signal n'est pas arrivé
3) Task_timer prend le mutex mut puis affiche "Tache 1" sur la sortie standard stdout
4) Task_timer envoie ensuite le signal synchro puis se met en attente du signal synchro2 (relâche le mutex mut car le signal n'est pas arrivé)
5) Task_read reçoit le signal synchro et prends donc le mutex mut puis affiche "Tache 2" en sortie
6) Task_read envoie ensuite le signal synchro2 puis libère le mutex mut et reboucle
7) Task_timer recoit le signal synchro 2, libere le mutex mut et reboucle
Or, en sortie il n'y a que le premier message "Tache 1" et en posant des points d'arrêts pour analyser ce qu'il se passe j'ai l'impression que mon code se bloque à l'étape 4.
Quelqu'un saurait-il m'expliqué pourquoi cela ne fonctionne pas comme je l'ai pensé et comme j'ai voulu le programmer ?
Secondement, le printf gère t'il bien le multithreads ? (c'est à dire est-ce que je peux m'y fier pour tester mes programmes ?)
En vous remerciant par avance,
esc39
