Discussion :

[TiTiSeb]

Bonjour,

j'écris une interface pour lire des données entrant d'un port USB.
Des qu'une donnée arrive, un thread lit la donnée, la convertie et l'affiche dans un Table.
le problème c'est que durant mes tests si j'augmente la fréquence d'envois des données sur le port à une donnée/ms j'obtiens rapidement l'erreur suivante:

Code :

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

1
2
3
4
5
6
7
Exception in thread "Thread-0" java.lang.StackOverflowError
	at org.eclipse.swt.internal.win32.OS.PostThreadMessage(OS.java:2411)
	at org.eclipse.swt.widgets.Display.wakeThread(Display.java:3961)
	at org.eclipse.swt.widgets.Synchronizer.addLast(Synchronizer.java:62)
	at org.eclipse.swt.widgets.Synchronizer.asyncExec(Synchronizer.java:81)
	at org.eclipse.swt.widgets.Display.asyncExec(Display.java:603)
	at ui.InputTrame_Viewer.addFrame(InputTrame_Viewer.java:132)

la ligne 132 et la deuxième ligne du code suivant:

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
public void addFrame(final CanTrame trame) {
		ui.getDisplay().asyncExec(new Runnable() {
			public void run() {
				TableItem newLigne = new TableItem(ui, SWT.NONE);
 
				// Time
				newLigne.setText(0, trame.getStrTime());
				// Priority
				newLigne.setText(1, String.valueOf(trame.getPriority()));
				// Transmitter
				newLigne.setText(2, trame.getStrTransmitter());
				// Recipient
				newLigne.setText(3, trame.getStrRecipient());
				// id
				newLigne.setText(4, trame.getStrId());
				// Length
				newLigne.setText(5, String.valueOf(trame.getLength()));
				// Data
				newLigne.setText(6, trame.getStrData());
 
				if (!btScrollLock.getSelection())
					ui.showItem(newLigne);
 
				TxtNbTrameReceived.setText(
						String.valueOf(Integer.valueOf(TxtNbTrameReceived.getText()) + 1));
			}
		});
	}

est ce que quelqu'un peut me dire comment gérer/éviter cette erreur?

Merci d'avance.

[darkxan]

Le nom de l'erreur parle de lui même : la pile a explosé... Tu peux lançer ton programme avec plus d'espace mémoire pour la pile (il faut regarder les options de la jvm) ou alors faire en sorte que ton programme alloue moins de mémoire.

Tu pourrais par exemple si c'est possible (je n'ai pas regardé ton code) réutiliser des objets pour éviter la création et la destruction qui est assez longue à cause du GC.

En regardant ton code, je ne sais pas quand est-ce que le code "addFrame" est appelé. S'il est appelé à chaque fois qu'une trame arrive alors le mieux serait de créer un pool de threads (ou laisser la gestion par un seul thread) au lieu de recréer à chaque fois un thread.

A mon avis (si "addFrame" est appelé pour chaque trame), le problème vient de là car si un 1 000 000 de trames arrivent alors tu vas créer 1 000 000 de threads synchronisé sur l'EDT...

EDIT: Comme ça, je pense que le mieux serait de faire un thread qui attends à l'infini les données sur le port USB et qui les écrit dans une mémoire partagée. Un autre thread serait quant à lui chargé tout les x période de temps d'afficher les nouvelles valeurs de la mémoire partagée.

[TiTiSeb]

même conclusion que toi. toutefois je ne sais pas comment faire pour que deux threads accèdent à une mémoire partagé .

j'ai une threads qui surveille l'arrivée de donnée sur le port. il rempli un buffer circulaire (un byte[]).

après avoir vidé le buffer d'entré dans le buffer circulaire, le thread lance une fonction qui décode les données pour trouver une trame (CanTrame). S'il en trouve une il lance la fonction "addFrame". et donc autant de threads synchronisé sur l'EDT que de trame reçue.

2 solutions si je te suis:
- identifier le buffer d'entré comme donnée partagée entre deux threads
- identifier un tableau de CanFrame donnée partagée entre deux threads

je préfère la 1er solution. toutefois je ne sais pas comment faire pour lancer un thread qui se réveille de "temps en temps" et lit de façon "synchronisé" (notion de producteur/consommateur je crois) les données partagées pour afficher les trames reçues.

quelqu'un as t'il un bout de code ou un lien internet?

[soft0613]

Tu dois utiliser la synchronisation (il y a des cours la dessus sur developpez.com).
Tu dois créer un objet dont l'acces a ses méthodes est synchronisé, ainsi un seul thread écrit ou lit les données pendant que l'autre attend, lorsqu'il a fini il donne la main au thread qui est en attente.
Tu devras utiliser les méthodes wait(), wait(long), notify(), notifyAll() de la classe Object, lit la doc de sun déja pour comprendre a quoi elles servent.

[TiTiSeb]

Effectivement j'ai résolut le probleme en lancant un thread avec le run suivant:

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
synchronized public void run() {
		//final Object This = this;
		
		while(IsOpen){
			while (InputBuffer.length < 9){		// 9 is min size of message
				try {
		            //passive waiting
		            wait();
		        } catch(InterruptedException ie) {
		            ie.printStackTrace();
		        }
			}
			Parent.getDisplay().asyncExec(new Runnable(){
				public void run(){
					DecodeInputMsg();
				}
			});
		}
	}

et un notifyall() dans le thread qui reçoit les message.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
synchronized private void RxManager(byte[] RxMsg){
		if (InputBuffer.length > 0){
			byte[] tmp = new byte[InputBuffer.length + RxMsg.length];
			System.arraycopy(InputBuffer, 0, tmp, 0, InputBuffer.length);
			System.arraycopy(RxMsg, 0, tmp, InputBuffer.length, RxMsg.length);
			InputBuffer = tmp;
		}
		else
			InputBuffer = RxMsg.clone();
		
		notifyAll();
	}