Discussion :

[esc39]

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 :

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
 
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

[dalfab]

Bonjour,
Je ne vois pas de problème particulier dans ce code.

Attention, la tache timer oublie d'attendre, on pourrait ajouter (en dehors du mutex) un simple delai.
Les pthread_cond sont normalement toujours utilisés avec une variable pour transporter l'information. On est rarement dans ce cas ultra-simple (ajoute un 3ième thread et plus rien ne marchera).
D'une zone protégée par un mutex, on doit sortir très rapidement, y mettre des printf n'est pas du tout une bonne habitude.
2 mutex sont créés, heureusement tu n'en utilises qu'un.
Et printf peut être utilisé en multi-thread si évidemment la bibliothèque utilisée est bien multi-thread, dans le cas contraire il aura un comportement erratique (mais je doute qu'une bibliothèque non multi-thread fournisse pthread_create!)

[esc39]

Merci beaucoup pour toutes ces informations. Je vous tiens au courant.
esc39