Discussion :

[tiamat]

Bonjour à tous,

j'ai un petit problème de wait sur un Thread qui même après un appel de la méthode notify ne se débloque pas...

voici le code de la casse Thread:

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
 
public class USBThread extends Thread{
...
 
	public static USBThread getInstance(){
	    if( instance == null ) { instance = new USBThread(); }
	    return instance;
	}
 
	public void run(){
                .......
		while(fin != 1){
			synchronized(this){
				try{
					this.wait();
					log.debug("Traitement du message");
                                        process();
 
				}catch(Exception e){}
			}
		}

et voici la classe qui utilise ce thread.
En fait je crée un objkect USBThread, je récupère sa référence, je modifie un de ses objet et je notifie le thread pour qu'il puisse processer mon objet envoyé:

Code :

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

1
2
3
4
5
6
7
 
                        USBThread usb = USBThread.getInstance();
 
			synchronized(usb){
				usb.sendCommand(commande);
				usb.notify();
			}

lorsque cette classe appelle la méthode notify de mon threadUSB, je n'ai pas d'affichage de la chaine "Traitement du message", ni de lancement de la méthode process().

Quelqu'un pourrait m'éclairer à ce sujet ? je bloque....

Merci !
Tiamat.

[adiGuba]

Salut,


Question bête mais : le thread est-il bien lancé ?
Sinon avec Java 5 tu peux utiliser une BlockingQueue pour cela


a++

[tiamat]

Salut adiGuba,

oui je te confirm que le Thread est bien lancé car j'effectue une initialisation dans le Thread avant de pouvoir processer mes commandes (ouverture du port USB).

Je vais regarder les Blocking Queue, mais étant donné que mon besoin reste assez basique, je sais que je n'aurais toujours qu'un seul thread USB, le seul truc c'est que c'est lui qui est garant de la connection USB et toute demande de traitement de commande doit passer par lui...

pour moi la boucle infinie en attente de notify() semblait une solution parfaite pour mettre le Thread en attente de processing de commande...

[Mister-Joker]

Salut,


Question bête mais : le thread est-il bien lancé ?


a++

Il n'y a aucun appel de la méthode start() pour lancer le thread.

[Mister-Joker]

Salut:

Code :

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

1
2
3
4
5
6
7
public static USBThread getInstance(){
     if( instance == null || !instance.isAlive())  { 
          instance = new USBThread();
          instance.start();
     }
     return instance;
}

[adiGuba]

pour moi la boucle infinie en attente de notify() semblait une solution parfaite pour mettre le Thread en attente de processing de commande...

Comme tu ne peux pas déterminer l'ordre d'exécution des threads, il est possible que le notify() soit exécuté AVANT le wait() : du coup ton thread s'endort et ne se réveille plus....


Il faudrait rajouter un double-check qui vérifie s'il y a des données avant le wait()...



Mais les BlockingQueue sont justement là pour résoudre ce problème :

• Un thread fait une boucle pour récupérer les éléments de la queue :
  

  Code :

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

  1
  2
  3
  4
  5
  while (true) {
      String cmd = queue.take(); // bloquant si vide
   
      // Traitement de "cmd"
  }

• Les autres threads pouvant à tout moment envoyer des données dans la queue, qui seront donc traiter dès que possible :
  

  Code :

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

  queue.offer( commande );

a++

[tiamat]

j'ai un peu regardé les BlockingQueue mais au plus j'y réfléchis au plus je me dit que l'utilisation des Thread "standards" est largement suffisante pour mon besoin (en tout cas pour le moment)...

donc je tente d'investiguer un peu plus sur mon problème...ça doit marcher !

du fait ta remarque sur l'ordre entre le notify et le wait est obligatoirement bon dans mon soft, mon Thread se met en wait() au démarrage de mon programme et je suis persuadé que que le notify arrive après.

donc si j'énumère:
- je suis sur que c'est le même Thread à qui j'envois un notify (en affichant la ref du Thread j'ai vu que c'est le même instancié au début et celui à qui j'envois un notify)
- je n'ai pas d'exception, j'ai juste mon thread qui n'est jamais réveillé

Avez vous une idée ? si vous voulez je peux vous faire passer un peu plus de code pour expliquer un peu mieux !

Merci,
Tiamat.

[tchize_]

met un log avant le wait(), pour être sur.
met un log avant le notify(), pour etre sur aussi.
a mon avis, soit le thread est pas lancé, soit le notify arrive trop tot par rapport au wait, soit tu fait pas le notify, soit encore t'as plusieurs trucs qui font un wait sur le meme objet

et en multi threading, on ne peut pas être persuadé qu'un notify arrive bien après un wait, il faut en etre sur, et ton code n'en donne aucune garantie

[adiGuba]

du fait ta remarque sur l'ordre entre le notify et le wait est obligatoirement bon dans mon soft, mon Thread se met en wait() au démarrage de mon programme et je suis persuadé que que le notify arrive après.

Rien ne garantie cela dans le code que tu as donné...

D'ailleurs en reproduisant un code proche du tiens j'obtiens le même type de problème : le notify() est appelée avant le wait() :

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
	Thread thread = new Thread() {
		@Override
		public void run() {
			synchronized(this) {
				try {
					System.out.println("Wait");
					this.wait();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	};
	thread.start();
 
	synchronized(thread) {
		System.out.println("Notify");
		thread.notify();
	}

Tu as deux threads différents, et l'ordre d'exécution peut entre les deux threads peut fortement varier selon plusieurs conditions (l'OS, la charge système, etc.). Il est impossible de garantir l'ordre d'exécution exact...



Donc si tu veux faire cela avec des wait/notify, il faut que tu utilises une variables externes (un booléen ou simplement la taille d'une liste) afin d'éviter d'endormir ton thread s'il y a déjà eu un notify (par exemple si tu as déjà reçu une commande.

En gros ton thread devrait ressembler à ceci :

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
class MyThread extends Thread {
 
	// Les accès à la liste doivent être synchronisé
	private final List<String> list = new LinkedList<String>();
 
	/**
         * La méthode sendCommand() doit être appellé depuis un autre thread
         * pour "passer" un objet au thread...
         */
	public void sendCommand(String command) {
		synchronized(this) {
			// On a le verrou, on peut modifier la liste :
			this.list.add(command);
			// Et on signale cet ajout au thread :
			this.notify();
		}
	}
 
	/**
         * La méthode getCommand() doit être appelée par le thread pour récupérer
         * le premier élément reçu via sendCommand().
         * S'il n'y a aucun élément la méthode bloquera jusqu'à en recevoir un...
         */	
	protected String getCommand() {
		synchronized(this) {
			// On a le verrou, on peut vérifier l'état de la liste :
			while (list.isEmpty()) {
				// On endort le thread tant que la liste est vide :
				try {
					this.wait();
				} catch (InterruptedException e) {
					throw new RuntimeException(e);
				}
			}
			// Et on retourne le premier élément :
			return list.remove(0);
		}
	}
}

Et là si le notify est appelé AVANT le wait, tu n'endors pas le thread et tu traite de suite les données :

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
public class Main {
 
	public static void main(String[] args) {
 
		MyThread thread = new MyThread() {
			@Override
			public void run() {
				synchronized(this) {
					System.out.println("getCommand()");
					String command = getCommand();
					System.out.println("command="+command);
				}
			}
		};
		thread.start();
 
 
		System.out.println("setCommand()");
		thread.sendCommand("hello");
 
	}
 
}

Les BlockingQueue gèrent toute cette synchronisation pour toi :

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
class MyThread extends Thread {
 
	// Les BlockingQueue gère toute la partie synchronisation,
	// et peuvent donc être utilisé directement depuis n'importe quel thread :
	private final BlockingQueue<String> queue = new LinkedBlockingQueue<String>();
 
	/**
         * La méthode sendCommand() doit être appelée depuis un autre thread
         * pour "passer" un objet au thread...
         */
	public void sendCommand(String command) {
		this.queue.offer(command);
	}
 
	/**
         * La méthode getCommand() doit être appelée par le thread pour récupérer
         * le premier élément reçu via sendCommand().
         * S'il n'y a aucun élément la méthode bloquera jusqu'à en recevoir un...
         */
	protected String getCommand() {
		try {
			return this.queue.take();
		} catch (InterruptedException e) {
			throw new RuntimeException(e);
		}
	}
}

a++

[tiamat]

Merci pour vos remarques,
je tente encore un peu de m'acharner dessus et si je vois que c'est trop galère effectivement je me pencherais un peu plus sur les BlockingQueues....

Bref, j'ai rajouté quelques logs supplémentaires, voici le ThreadUSB:

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
 
	//Merci Mister Joker ! ;-)
        public static USBThread getInstance(){
	    if( instance == null || !instance.isAlive() ) {
	    	instance = new USBThread(); 
	    	instance.start();
	    }
	    return instance;
	}
 
	public void run(){
		Random rand = new Random();
		ref = rand.nextInt(9999);
		instance = this;
		cmd = null;
		log.debug("Demarrage Thread USB "+ref);
		//demarrage du thread d'ecoute USB
		log.debug("Thread USB initialise.");
		//com.start();		
		while(fin != 1){
			synchronized(this){
				try{
					log.debug("Thread USB en Wait");
					this.wait();
					log.debug("Thread USB sorti du wait, traitement du message");
					process();				
					cmd = null;				
				}catch(Exception e){
					if (log.isDebugEnabled()) {
						log.debug("Erreur de Thread USB.... :("+e.toString());
					} else {
						log.error(e, e);
					}
				}
			}
		}
	}

voici la Servlet qui l'appelle:

Code :

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

1
2
3
4
5
6
7
8
9
 
...
USBThread usb = USBThread.getInstance();
....
			synchronized(usb){
				log.debug("Envoi de Notify au Thread USB ");
				usb.sendCommand(commande,step,vitesse);
				usb.notify();
			}

pour ce qui est des logs, les voicis:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
12:42:04,674 WARN  [com.emi.module.Main]:25 - Demarrage du module [EMI2]
12:42:04,674 WARN  [com.emi.module.Main]:26 - Module en mode ONLINE
12:42:04,705 DEBUG [com.emi.Config]:64 - Modifie Module Mode: OFFLINE ->ONLINE
12:42:04,705 DEBUG [com.emi.module.USBCard]:69 - Demarrage Thread USB 841
12:42:04,705 DEBUG [com.emi.module.USBCard]:80 - Thread USB initialise.
12:42:04,705 DEBUG [com.emi.module.USBCard]:85 - Thread USB en Wait
12:42:40,111 DEBUG [com.emi.module.Servlets]:90 - Commande:go
12:42:40,111 DEBUG [com.emi.module.Servlets]:106 - On envoit la commande au Thread USB
12:42:40,111 DEBUG [com.emi.module.Servlets]:111 - Envoi de Notify au Thread USB
12:42:40,111 INFO  [com.emi.module.USBCard]:31 - commande recue a envoyer, je suis le Thread : 841

selon les logs, on voit bien que le ThreadUSB instance 841 est en wait avant le notify, et je suis bien sur d'envoyer le notify au bon Thread étant donné que la commande est bien reçue par le ThreadUSB ayant la bonne ref 841.

qu'en pensez vous ?

[tiamat]

En parallèle j'ai essayé les BlockingQueues que tu me proposes adiGuba, mais j'ai le même résultat...

voici l'extrait du code modifié:

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
 
ThreadUSB:
	public void sendCommand(String command){
		log.info("Thread USB sendCommand recu, je suis le Thread : "+ref);
		this.queue.offer(command);
 
	}
 
	protected String getCommand() {
		try {
			return this.queue.take();
		} catch (InterruptedException e) {
			throw new RuntimeException(e);
		}
	}
....
		log.debug("Thread USB initialise.");
		//com.start();		
		while(fin != 1){
			synchronized(this){
				try{
					log.debug("Thread USB en Wait");
					//this.wait();
					getCommand();
					log.debug("Thread USB sorti du wait, traitement du message");
					process();				
					cmd = null;				
				}catch(Exception e){
					if (log.isDebugEnabled()) {
						log.debug("Erreur de Thread USB.... :("+e.toString());
					} else {
						log.error(e, e);
					}
				}
			}
		}

et voici mon appellant:

Code :

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

1
2
3
4
 
			log.debug("la Servlet envoit la commande au Thread USB");
			log.debug("Envoi de Notify au Thread USB ");
			usb.sendCommand(commande,step,vitesse);

voici le résultat des Logs:

Code :

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

1
2
3
4
5
6
7
8
9
10
 
13:15:51,788 WARN  [com.emi.module.Main]:25 - Demarrage du module [EMI2]
13:15:51,788 WARN  [com.emi.module.Main]:26 - Module en mode ONLINE
13:15:51,803 DEBUG [com.emi.Config]:64 - Modifie Module Mode: OFFLINE ->ONLINE
13:15:51,803 DEBUG [com.emi.module.USBCard]:83 - Demarrage Thread USB 7781
13:15:51,803 DEBUG [com.emi.module.USBCard]:94 - Thread USB initialise.
13:15:51,803 DEBUG [com.emi.module.USBCard]:99 - Thread USB en Wait
13:16:06,207 DEBUG [com.emi.module.Servlets]:105 - la Servlet envoit la commande au Thread USB
13:16:06,207 DEBUG [com.emi.module.Servlets]:107 - Envoi de Notify au Thread USB
13:16:06,207 INFO  [com.emi.module.USBCard]:32 - Thread USB sendCommand recu, je suis le Thread : 7781

Le résultat est donc le même en utilisant les BlockingQueue, j'ai également tenté de lever le bloc synchronized dans ma méthode run() de mon Thread mais le résultat est le même...

[tchize_]

1) es-tu sur d'avoir bien compilé après avoir retiré le wait()?
2) pourquoi ne stocke tu pas le retour de getCommand() quelque part
3) j'ai testé ton code, avec quelques modif (retiré log4j), il fonctionne parfaitement:

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
78
79
80
package pack1;
 
import java.util.Random;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
 
public class USBThread extends Thread {
 
    BlockingQueue<String> queue = new ArrayBlockingQueue<String>(50);
    private int ref;
    private static USBThread instance;
    private int fin;
    private String cmd;
 
    public void sendCommand(String command){
        System.out.println("Thread USB sendCommand "+command+" recu , je suis le Thread : "+ref);
        this.queue.offer(command);
 
    }
 
    protected String getCommand() {
        try {
            return this.queue.take();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
 
    //Merci Mister Joker ! ;-)
    public static USBThread getInstance(){
        if( instance == null || !instance.isAlive() ) {
            instance = new USBThread();
            instance.start();
        }
        return instance;
    }
 
    public void run(){
        Random rand = new Random();
        ref = rand.nextInt(9999);
        instance = this;
        cmd = null;
        System.out.println("Demarrage Thread USB "+ref);
        //demarrage du thread d'ecoute USB
        System.out.println("Thread USB initialise.");
        //com.start();
        while(fin != 1){
            synchronized(this){
                try{
                    System.out.println("Thread USB en Wait");
                    //this.wait();
                    cmd = getCommand();
                    System.out.println("Thread USB sorti du wait, traitement du message");
                    process();
                    cmd = null;
                }catch(Exception e){
                    e.printStackTrace();
                }
            }
        }
    }
 
    private void process() {
        System.out.println("processing "+cmd);
        try {
            Thread.sleep(50); //simule du temps passé à traiter l'opération
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
 
    public static void main(String[] argv) throws InterruptedException{
        Random r = new Random();
        for (int i=0;i<10;i++){
            Thread.sleep(r.nextInt(30));
            getInstance().sendCommand("command "+i);
        }
    }
}

résultat:

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
Demarrage Thread USB 1624
Thread USB initialise.
Thread USB en Wait
Thread USB sendCommand command 0 recu , je suis le Thread : 1624
Thread USB sorti du wait, traitement du message
processing command 0
Thread USB sendCommand command 1 recu , je suis le Thread : 1624
Thread USB sendCommand command 2 recu , je suis le Thread : 1624
Thread USB en Wait
Thread USB sorti du wait, traitement du message
processing command 1
Thread USB sendCommand command 3 recu , je suis le Thread : 1624
Thread USB sendCommand command 4 recu , je suis le Thread : 1624
Thread USB sendCommand command 5 recu , je suis le Thread : 1624
Thread USB en Wait
Thread USB sorti du wait, traitement du message
processing command 2
Thread USB sendCommand command 6 recu , je suis le Thread : 1624
Thread USB sendCommand command 7 recu , je suis le Thread : 1624
Thread USB sendCommand command 8 recu , je suis le Thread : 1624
Thread USB sendCommand command 9 recu , je suis le Thread : 1624
Thread USB en Wait
Thread USB sorti du wait, traitement du message
processing command 3
Thread USB en Wait
Thread USB sorti du wait, traitement du message
processing command 4
Thread USB en Wait
Thread USB sorti du wait, traitement du message
processing command 5
Thread USB en Wait
Thread USB sorti du wait, traitement du message
processing command 6
Thread USB en Wait
Thread USB sorti du wait, traitement du message
processing command 7
Thread USB en Wait
Thread USB sorti du wait, traitement du message
processing command 8
Thread USB en Wait
Thread USB sorti du wait, traitement du message
processing command 9
Thread USB en Wait

[tiamat]

1) es-tu sur d'avoir bien compilé après avoir retiré le wait()?

oui j'ai effectivement bien compilé, j'ai bien fait un clean plusieurs fois.

2) pourquoi ne stocke tu pas le retour de getCommand() quelque part

juste parce que je ne procédais pas comme ça pour passer mes arguments au Thread, je pourrais effectivement utiliser cette méthode mais je ne pense pas que cela puisse bloquer mon thread

3) j'ai testé ton code, avec quelques modif (retiré log4j), il fonctionne parfaitement:

J'ai repris ton code d'exemple pour isoler cette fonction et chez moi aussi il tourne...donc je ne comprend vraiment pas pourquoi mon thread ne se réveille pas...
je bloque là...

[tchize_]

ben donne nous tout le code de ta classe Thread et de l'appel à celle-ci, parce que là, nous, on a que des bouts qui a priori fonctionnent (cf mon code)

[tiamat]

le voici:

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
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
 
package com.emi.module.USBCard;
 
import java.util.*;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.LinkedBlockingQueue;
 
import com.emi.module.Entity.*;
 
import org.apache.log4j.Logger;
import com.emi.module.Entity.XMLOperativeCommand;
 
public class USBThread extends Thread{
 
	private static final Logger log = Logger.getLogger("com.emi.module.USBCard");
	private static USBThread instance;
	private static int ref;
	private int fin = 0;
	private final BlockingQueue<Action> queue = new LinkedBlockingQueue<Action>();
	private Action action;
	private ComUSB com;
	private XMLOperativeCommand cmd;
 
	public void sendCommand(String command, String step, String vitesse){
		log.info("Thread USB sendCommand recu, je suis le Thread : "+ref);
		action.setName(command);
		action.setStep(step);
		action.setSpeed(vitesse);
		this.queue.offer(action);
 
	}
 
	protected Action getCommand() {
		try {
			log.debug("Thread USB getCommand: en attente de take(), ref:"+ref);
			return this.queue.take();
		} catch (InterruptedException e) {
			throw new RuntimeException(e);
		}
	}
 
 
	public static USBThread getInstance(){
	    if( instance == null || !instance.isAlive() ) {
	    	log.debug("GetInstance Nouvelle reference creee, ref:"+ref);
	    	instance = new USBThread(); 
	    	instance.start();
	    }
	    return instance;
	}
 
	public String getUSBState(){
		return "SIMULATED OK";
	}
 
	public int getRef() {
		return ref;
	}
 
	public void setRef(int ref) {
		this.ref = ref;
	}
 
	public void fin(){
		fin = 1;
	}
 
	public void run(){
		Random rand = new Random();
		ref = rand.nextInt(9999);
		instance = this;
		cmd = null;
		log.debug("Demarrage Thread USB "+ref);
		//demarrage du thread d'ecoute USB
		log.debug("Thread USB initialise.");
		while(fin != 1){
			//synchronized(this){
				//try{
					log.debug("Thread USB en Wait");
					//this.wait();
					action = getCommand();
					log.debug("Thread USB sorti du wait, traitement du message");
					process();				
					cmd = null;				
				/*}catch(Exception e){
					if (log.isDebugEnabled()) {
						log.debug("Erreur de Thread USB.... :("+e.toString());
					} else {
						log.error(e, e);
					}
				}*/
			//}
		}
	}

Je te remercie de ton aide !

[tiamat]

pardon j'ai oublié l'appellant....

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
 
 
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
 
import org.apache.log4j.Logger;
 
 
public class EMIModuleServlet extends HttpServlet{
 
	private static final long serialVersionUID = 1L;
	private static final Logger log = Logger.getLogger("com.emi.module.Servlets");
	private ModuleConfiguration config = new ModuleConfiguration();
	private String resultat = "attente de commande";
	private String commande="";
	private final ConcurrentLinkedQueue<Action> queue = new ConcurrentLinkedQueue();
	private Action action= new Action();
	private String vitesse=null;
	private String step=null;
	public HttpSession session_module;
 
	public void init() throws ServletException {
 
	}
 
	public void destroy() {
	}
 
	public void doGet(HttpServletRequest request, HttpServletResponse response)
	throws ServletException, IOException {
 
		USBThread usb = USBThread.getInstance();
		//on recupere le path de la requete
		String cmd=request.getPathInfo();
		request.setAttribute("moduleState", config.getMode());
		request.setAttribute("moduleName", config.getModuleName());
		request.setAttribute("USBState", usb.getUSBState());
		session_module = request.getSession(true);
 
		commande = request.getParameter("commande");
		step = request.getParameter("step");
		vitesse = request.getParameter("vitesse");
		resultat = "Commande:"+commande+" Vitesse:"+vitesse;
		request.setAttribute("resultat", resultat);
		//Envoi de la commande au Thread USB.
		log.debug("la Servlet envoit la commande au Thread USB");
		//synchronized(usb){
			log.debug("Envoi de Notify au Thread USB ");
			usb.sendCommand(commande,step,vitesse);
			//usb.notify();
		//}
 
		getServletContext().getRequestDispatcher("/console.jsp").forward(request, response);
	}
 
	public void doPost(HttpServletRequest request, HttpServletResponse response)
	throws ServletException, IOException {
 
		doGet(request, response);
 
	}
 
 
 
}

le code n'est pas clean...un peu normal j'ai tenté pas mal de choses en // et je dois nettoyer tout ça plus tard !

[tchize_]

a priori, ca

Code :

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

action.setName(command);

dans sendCommand, ca va systématiquement lever un NullPointerException puisque ton champ action n'est jamais initialisé.

du coup en fait tu n'envoie jamais la moindre commande dans ton code.

La méthode correcte serait:

Code :

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

1
2
3
4
5
6
7
8
9
    public void sendCommand(String command, String step, String vitesse){
        log.info("Thread USB sendCommand recu, je suis le Thread : "+ref);
        Action action = new Action();
               action.setName(command);
        action.setStep(step);
        action.setSpeed(vitesse);
        this.queue.offer(action);
 
    }

ce qui, accessoirement, en utilisant une variable de méthode plutot qu'un champ global, t'éviterais aussi d'essayer de stocker toujours la même instance réécrasée de Action dans ta queue (ce qui n'aurait aucun sens)

Ce qui m'étonne, c'est que tu aurais du le voir ici ton NullPointerException, et il aurait du s'afficher dans ta pages html:

Code :

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

usb.sendCommand(commande,step,vitesse);

[tiamat]

Effectivement ça venait de là...
je te remercie parce que j'avais effectivement oublié l'instanciation de l'objet Action...
mais par contre je n'avais aucune exception de générée d'où ma difficulté à trouver mon erreur ! en tout cas je te remercie tchize (et adiGuba) pour ton aide.
à charge de revanche ! ;-)

++
Tiamat.