Discussion :

[Invité]

Bonjour ,

J'ai 3 thread a executer

Un thread envoie
un thread reception
un thread reception2

Les 3 sont liés a des fonctions qui ont des boucles infinis
Lorsque l'on envoie , on a reception ensuite , puis si on a reception on a reception 2 et tout ça à l'infini .

Cependant , je n'arrive pas à faire cela .

J'ai fais un truc comme ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
pthread_create(&envoi, NULL, thread_envoi,(void*)NULL);
pthread_join(envoi,NULL);  //  On attend que envoi finit      
 
 pthread_create(&reception, NULL, thread_reception,(void*)NULL);
pthread_join(reception,NULL);  // on attend qu'il finisse 
 
pthread_create(&reception2,NULL,thread_reception2,(void*)NULL);
pthread_join(reception2,NULL);  // on attend qu'il finisse

J'espère que vous sauriez m'aider

Edit : Apparement , vu que ce sont des boucles infinis , cela bloque des l'attente du thread envoi .

Edit2 : J'ai pensé à enlever les pthread_join() : Cependant , les trois threads s'exécutent directement et le programme se finit .

Y a t il une solution contre ça ?

[koala01]

Salut,

Ce que tu dois comprendre, c'est que lorsque tu travailles avec de threads, il ne travaillent pas l'un après l'autre, mais en même temps.

Tu peux très bien avoir un envoi qui est effectué en meme temps que la réception2 (sans doute d'une chose pour laquelle l'envoi a été fait avant ), ainsi que toutes les autres combinaisons possibles

Si tu veux que les trois actions (envoi, réception1 et réception2) se fasse dans cet ordre, il faudrait sans doute qu'elles soient, clairement, effectuées dans cet ordre au sein d'un seul et unique thread.

Par contre, rien ne t'empêcherais d'avoir plusieurs threads qui font les trois actions de manière successives, ainsi, tu aurais plusieurs envois suivis de reception1 et de réception2 qui pourraient être effectués en meme temps

[Invité]

J'ai mis un pthread_join(reception2,NULL) a la toute fin , ce qui me fait marcher les 3 threads . Sauf que de temps en temps , le deuxieme et troisième s'inverse dans l'ordre . Ce qui va m'obliger a mettre des mutex non ?

[humitake]

Bonjour,

pthread_join() signifie que tu demande d'attendre que l'intégralité de tes thread soit terminé avant de continuer.

Ce que t'as expliqué koala01 c'est que tu ne peux pas faire ce que tu veux de la façon dont tu l'a fait.
Actuellement tes 3 threads sont exécuté en 'simultané' dans n'importe quel ordre. Je t'invite à te renseigné sur le fonctionnement des threads pour mieux comprendre

Je pense donc que tu est la face à un problème d'analyse. Que souhaite tu faire exactement ?
Peux tu nous décrire le fonctionnement que tu souhaiterais obtenir par un exemple ?

[Invité]

D'accord , merci de votre aide .

J'ai une communication entre 2 applis .

Sur mon programme , je souhaiterais envoyer des informations et recevoir une analyse de ces résultat ( que la seconde appli m'envoie automatiquement une fois les informations reçu) puis ensuite recevoir autre chose juste après ça , et tout cela tant que je ne quitte pas le programme ( par exemple la saisie d'un caractère . ) . Bien entendu en boucle infini et dans cette ordre là , c'est à dire envoi , puis reception , puis reception deuxième .

J'espère que j'ai été clair .

[fozzeuh]

Et pourquoi tu utilises pas juste un thread qui va executer une fonction après l'autre ?

en gros un thread générale et juste appel à des fonctions qui font le travail

[Invité]

Tu veux dire lancer 3 trois fois le même thread ?

[fozzeuh]

Non tu fais un thread qui va donc tourner à l'infini et dans ce thread tu fais un appels à tes 3 fonctions(envoi, réception1 et réception2) c'est une possibilité je pense , après tu peux aussi faire 3 thread et tu vas devoir les gèrer avec des mutex ou d'autres techniques mais je sais pas si tu as vraiment besoin de 3 threads.

Car 3 threads ça va signifier "normalement" 3 "fonctions" (traitement dans ton thread) plus ou moins en même temps.

Je ne sais pas si je suis très clair.

[Invité]

Salut ,

Je préfère rester dans le choix de 3 threads , j'ai des contraintes

J'avais essayé de mettre des mutex mais ça ne fonctionnait pas comme je le voulais ( conditions , signaux etc .. )

[koala01]

Salut ,

Je préfère rester dans le choix de 3 threads , j'ai des contraintes

J'avais essayé de mettre des mutex mais ça ne fonctionnait pas comme je le voulais ( conditions , signaux etc .. )

A vrai dire, je crois que tu as très mal compris les différentes contraintes, et que tu es parti sur quelque chose de tout à fait erroné

Selon moi, tu as sans doute deux contraintes:

1. d'une part, le fait que tout fonctionne sans arrêt
2. d'autre part, le fait de pouvoir lancer plusieurs succession d'envoi, de réception1 et de réception2 en simultané.

Pour résoudre la première contrainte, ce n'est déjà pas envoi qui devrait tourner de manière infinie, mais "quelque chose d'autre" qui attendrait un signal "envoie telle information".

Lors que "signal" serait perçu, tu lancerais d'abord l'instruction "envoi", puis, une fois qu'elle est finie (il ne sert à rien d'attendre la réception avant que l'envoi ne soit terminé ) l'instruction "reception1", et enfin lorsque reception1 a fini son boulot, l'instruction reception2.

Ces trois étapes sont strictement séquentielles: il n'y a strictement aucune raison pour vouloir les effectuer en parallèle (dans des threads séparés).

Ta deuxième contrainte nécessite sans doute le recours au threads, mais pas de la manière dont tu l'as envisagée.

Il n'est, en effet, pas impossible que tu veuilles envoyer un deuxième jeu de donnée alors que la procédure complète n'est pas encore achevée pour l'envoi précédant.

Comme je l'ai dit, il ne s'agit absolument pas de faire fonctionner envoi, reception1 et reception2 en parallèle, il s'agit de faire en sorte que l'on puisse exécuter l'ensemble de ces trois actions en parallèle et de manière indépendante.

Pour ce faire, il te faut une fonction "atomique" (ou qui puisse en tout cas être considérée comme telle) qui appelle ces trois fonctions.

Elle prendrait sans doute la forme de quelque chose proche de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
void sendAndReceive(/* ... */){
    send(/* ... */);
    firstReceive(/* ... */);
    secondReceive(/*... */ );
}

Ce serait cette fonction là que tu passerais à un seul thread (créé pour l'occasion, ou maintenu en attendant son utilisation ) pour qu'elle soit utilisée "quand nécessaire".

En veillant à ce que chaque thread soit en mesure de travailler sur ses propres données, tu pourras meme carrément te passer des mutexes

[Médinoc]

Au passage, pour la question de base, la première chose à tenter était ceci:

Code C/C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
pthread_create(&envoi, NULL, thread_envoi,(void*)NULL);
pthread_create(&reception, NULL, thread_reception,(void*)NULL);
pthread_create(&reception2,NULL,thread_reception2,(void*)NULL);
 
pthread_join(envoi,NULL);  //  On attend que envoi finit      
pthread_join(reception,NULL);  // on attend qu'il finisse 
pthread_join(reception2,NULL);  // on attend qu'il finisse