Lancer un thread

Bonjour,

J'ai une classe qui extend la classe Thread et qui implements l'interface MessageListener
Dans cette classe j'ai donc une méthode run qui fait une connexion au serveur activemq et qui ensuite appel la méthode onMessage
Mon problème est que le statut de mon traitement est null dans ma méthode run alors qu'il est pas null dans ma méthode on message à la fin du traitement

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

public void run{ public void lireMessage(){ //Connexion au serveur Active MQ receiver.setMessageListener(this);   System.out.println(traitement); }   public void onMessage(Message message){ //Traitement   traitement = true

---

Merci de votre aide

tu peux donner ton code, pas des bribes grammaticalement incorrectes?

J'ai donné les méthodes qui sont contenu dans la classe qui extends thread
Il y a liremessage, on message et rubrique qui appelle liremessage

N'empêche, il est impossible de deviner l'enchaînement des appels (où est appelée lireMessage() par exemple, que fait run()...), les variables dont tu parles et leurs caractéristiques (scope, initialisation, synchronisation...), donc le fonctionnement de ton code et donc pourquoi il ne fonctionne pas, sans un code minimum.

Il y a juste une chose qu'on peut éventuellement entrevoir c'est que ton System.out.println() n'affichera très probablement jamais la valeur affectée à traitement dans onMessage().

Citation:

---

Envoyé par totot

J'ai donné les méthodes qui sont contenu dans la classe qui extends thread

---

Non tu as donné 6 ligne qui n'ont ni queue ni tête.

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

public classe LireMessage extends Thread implements MessageListener{ private boolean traitement; public void lireMessage(){ //Connexion au serveur activeMQ receiver.setMessageListener(this); // Permet d'appeler la méthode onMessage }   public void onMessage(Message message){ //Traitement du message   traitement = true; System.out.println("Traitement : "+traitement);   }   public void run(){ lireMessage(); System.out.println("Traitement : "+traitement); } }   public class Principal{ public void main{ LireMessage lireMessage = new LireMessage(); lireMessage.start(); }

---

Mon traitement reste à false dans run alors qu'il passe bien à true dans onMessage.

tu teste la valeur dans ton run immédiatement après avoir enregistré le listener. Les probabilités que la méthode onMessage aie eu le temps de s'exécuter sur les quelques nano secondes qui séparent tes deux instructions sont proche du néant. Le valeur ne passera à true que lorsque tu rentrera dans ton onMessage, chose que se passera dans une futur plus ou moins proche suivant la charge et la réactivité de la queue sur laquelle tu t'es enregistré.
Au passage, tel que présenté, ton Thread ne sert à rien. Il ne fait aucune opération qui nécessiterais un Thread. Tu pourrais appeler directement lireMessage plutôt que démarrer un Thread qui ne fait que l'appeler.

J'ai mis dans un thread pour qu'il écoute en parmanence

Un écouteur écoute par définition en quelque sorte en permanence, entre le moment où il est enregistré et celui où il est enlevé. Il réagit à chaque notification de l'émetteur de l'évènement, donc tout évènement sera traité. L'évènementiel c'est justement une façon de traiter des changements d'état sans faire de boucle qui teste le changement de manière permanente.

donc comment je peut faire

Citation:

---

Envoyé par totot

donc comment je peut faire

---

Citation:

---

Envoyé par tchize_

Tu pourrais appeler directement lireMessage plutôt que démarrer un Thread qui ne fait que l'appeler.

---

En faite, ma question c'est comment je peut faire car je doit attendre que le traitement soit fini pour poursuive mon traitement.
C'est pour cela que j'avais pensé à faire ceci:

Code:

---

1 2 3 4

while(lecteur.isAvelide){ System.out.println("En traitement"); } //Je continu mon programme principal

---

Mais là si je met pas de Thread, il va continuer mon programme principal sans attendre la fin du traitement?

Tu veux dire que tu un traitement dans le genre :

Code:

---

1 2 3 4

je fais des trucs... j'attends qu'un message arrive je fais d'autre trucs, qui dépendent des trucs faits au début et du message...

---

?

Oui exctament

Un moyen simple peut être d'utiliser un wait/notify (dans le cas de plusieurs messages, ou plus généralement d'attente de plusieurs résultats, utiliser un CountDownLatch, que tu peux même utiliser d'ailleurs au lieu du wait/notify)

Peut tu me mettre un exemple avec le wait / notify

Avec un CountDownLatch :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

CountDownLatch countDownLatch = new CountDownLatch(1); // on attend la fin de 1 traitement   receiver.setMessageListener( message-> {   // traitement message...   countDownLatch.countDown(); // le traitement est terminé   });   // traitements... countDownLatch.await(); // on attend le message // autre traitements...

---

Je le déclare ou le CountDownLatch? Dans la classe principale ou LireMessage?

Le code que je t'ai indiqué, c'est le code d'une méthode complète (mis à part la déclaration et l'initialisation de receiver, les traitements diverses que tu as à faire), qui correspond à ton processus.

Si tu préfères :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

public void faireTraitements(MessageConsumer receiver) { CountDownLatch countDownLatch = new CountDownLatch(1); // on attend la fin de 1 traitement   receiver.setMessageListener( message-> {   // traitement message...   countDownLatch.countDown(); // le traitement est terminé   });   // traitements... try { countDownLatch.await(); // on attend le message // autre traitements... } catch(InterruptedException e){ //... } }

---

et du coup dans ma classe principale, si je fait monObjet.getTraitement() j'arriverai bien à avoir true?

Ça représente quoi ce booléen ? Une notion de succès/échec ? Une notion de traitement terminé, peu importe son statut ?

D'ailleurs, j'y pense, dans le code je t'ai indiqué, tu peux gérer une notion de timeout (avec countDownLatch.await(30, TimeUnit.SECONDS) par exemple pour avoir un timeout de 30 secondes), et dans ce cas tu peux gérer un booléen pour indiquer que le traitement est bien allé jusqu'au bout, ou que le message n'est jamais arrivé (enfin dans les 30 secondes) (ou gérer ça par exception)

Pardons, je me suis trompé.
Dans onMessage, j'ai une autre variable qui est mi à jour, c'est le résultat du traitement.
Et ce résultat je veut le récupérer avec un getResultat() pour l'inclure dans la suite de mon programme principal

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

public void faireTraitements(MessageConsumer receiver) { CountDownLatch countDownLatch = new CountDownLatch(1); // on attend la fin de 1 traitement AtomicReference<Resultat> resultatTraitements = new AtomicReferece<>(); receiver.setMessageListener( message-> { // traitement message... resultatTraitements.set(new Resultat(...)); countDownLatch.countDown(); // le traitement est terminé }); // traitements... try { if ( countDownLatch.await(30, TimeUnit.SECONDS) ) { // on attend le message Resultat resultat = resultatTraitements.get(); // autre traitements... } else { // le message n'est pas arrivé au bout de 30 secondes d'attente } } catch(InterruptedException e){ //... } }

---

pas besoin de tout ça pour attendre un message. Vous ête occupés de vous compliquer le bourrichon là. Une queue jms ça peux travailler pas listener (asynchrone) ou par receive (synchrone). Là vous êtes occupé d'utiliser le mode asynchrone et essayer de trouver un moyen de le rendre synchrone :weird:

Si tu a besoin d'avoir traité ton message pour continuer, remplace ton

Code:

---

1 2 3 4

public void lireMessage(){ //Connexion au serveur activeMQ receiver.setMessageListener(this); // Permet d'appeler la méthode onMessage }

---

par

Code:

---

1 2 3 4 5

public void lireMessage(){ //Connexion au serveur activeMQ Message message = receiver.receive(); // Attends jusqu'à recevoir un message ou un timeout traiter(message); }

---

ainsi quand tu sortira de lireMessage, le message aura été traité.

Le traitement du message est effectué par la méthode onMessage qui est appelé grâce à setMessageListener

Ca je l'avais compris, je dis justement que c'est ce qu'il ne faut pas faire dans ton cas.

Citation:

---

Envoyé par tchize_

Code:

---

1 2 3 4 5

[...] Message message = receiver.receive(); // Attends jusqu'à recevoir un message ou un timeout [...] }

---

---

C'est sûr que s'il y a une méthode bloquante, c'est bien plus simple (je ne connais pas du tout ActiveMQ et son API, ceci explique cela).

Et je souhaite rester sur l'utilisation de ma méthode onMessage

il y a un besoin particulier? Parce que tu va vraiment te compliquer là vie entre: devoir attendre sur un Semaphore qu'un message soit traiter, la possibilité que non pas 1 mais 2 messages soient traité avant que tu ne reprenne la main, le risque que d'autre messages soient traités pendant que tu fais le reste de ton code, tu va devoir sortir une bonne grosse artillerie de code de synchronization.

Pour l'instant je me concentre sur le fait qu'il y a un seul message et non deux et qu'il soient traiter tout seul, qu'il y en ait pas d'autre pendant mon traitement

Citation:

---

Envoyé par totot

Pour l'instant je me concentre sur le fait qu'il y a un seul message et non deux et qu'il soient traiter tout seul, qu'il y en ait pas d'autre pendant mon traitement

---

Ouais, mais ça c'est pas la vraie vie. Tu ne peux pas garantir ça avec jms.