Discussion :

[TiTiSeb]

Je suis en train de coder un driver de lecture de données via le port série. Je stocke les données d'entrée dans un Byte[] (InputBuffer).

Un thread surveille la réception pour remplir le buffer d'entrée. voici le code:

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 AddData(byte[] RxMsg){
 
	//try {
		//wait();
 
		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();
 
	/*} catch (InterruptedException e) {
		e.printStackTrace();
	}*/
}

Un autre thread s'occupe d'afficher les données. ce dernier est réveillé dès la réception d'une donnée pour le premier thread (notifyAll()). Voici le code:

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
synchronized public void run() {
	while(enable){
		do{
			try {
				wait();	            //passive waiting
			} catch(InterruptedException ie) {
				ie.printStackTrace();
			}
		}while (InputBuffer.length < 5);		// 5 is min size of message
		
		do{
			display.asyncExec(new Runnable(){
				public void run(){
					DecodeInputMsg();
					InTrameViewer.setInputBuffer(InputBuffer.length);
				}
			});
		}while (InputBuffer.length > 0);		// 5 is min size of message
		
		//notifyAll();
	}
}

Tout se passe bien, je reçois bien les données sans perte. Mon problème et qu'avec se programme je dois attendre que le buffer soit vidé (boucle en rouge) pour le re-remplir par les données reçus (méthode AddData() ).

Ce que j'aimerai, c'est que des que je reçois une donnée (méthode AddData() ) je puisse mettre en pause la boucle en rouge pour ajouter les données à InputBuffer et ensuite reprendre la boucle en rouge.

Tout mes essais se sont terminés par le blocage des deux threads.

Je remercie par avance toutes personnes pouvant m'aider à résoudre se problème

[djsnipe]

Jette un coup d'oeil à http://java.sun.com/j2se/1.4.2/docs/...putStream.html

[TiTiSeb]

Bonjour,

Merci pour ta réponse. cette class répond tout a fait à mon probleme.

Toutefois j'en ai un autre car cette class ne supporte pas les méthode mark() et reset(). or j'en ai besoin dans la fonction "DecodeInputMsg()".

En effet si une trame complète n'est pas recu, je doit "remettre" les données dans le pipe et attendre la réception complète.

Quelqu'un connait une autre class qui implémente ces deux fonctions?

[djsnipe]

En effet si une trame complète n'est pas recu, je doit "remettre" les données dans le pipe et attendre la réception complète.

Pourquoi vouloir les remettre dans le flux pour les relire plus tard au lieu de les stocker localement et d'ajouter le morceau manquant lorsqu'il sera disponible pour traiter ta trame ?

[TiTiSeb]

Pour être franc: pour des raisons de simplicité et de temps. modifier un pointeur sur un buffer circulaire prend moins de temps que de faire des copies de byte.

De plus les deux méthodes existes donc je pense qu'il doit y avoir une class qui les implémentes. non?

Avant d'utiliser cette class j'avais codé une class représentant un buffer circulaire. non pb était un pb de gestion de code critique (exclusion mutuel) sur deux méthodes (putData(byte Data[]) et DecodedTrame getTrame() d'une même class).

L'exécution de PutData rempli le buffer par les données reçus en paramètres et réveille un thread (si il ne l'était pas déjà).
Le thread s'occupe de vider le buffer grâce à la méthode getTrame() pour décoder les données reçus. Si une trame n'est pas complètement reçu, il "laisse" les données disponible dans le buffer en attendant la réception complète.

Pour résumer:
- pb 1: existe-il une class dérivée de PipedInputStream et implémentant les méthodes mark et reset.
- pb 2: comment gérer l'exclusion mutuelle de deux méthodes sans avoir de famine et/ou de blocage.

Une réponse à l'un des deux problèmes me convient. Même si j'aimerais bien comprendre plus le fonctionnement des threads en résolvant le problème 2.

Merci de votre aide.

[atha2]

- pb 2: comment gérer l'exclusion mutuelle de deux méthodes sans avoir de famine et/ou de blocage.

Tu peux te renseigner sur les verrous et les semaphore (package java.util.concurrent et classe ReentrantLock et Semaphore)
Semaphore me semble plus adapté pour ce que tu veux faire :
blocage + famine = semaphore ^^
un exemple simple de verrous tiré de la javadoc

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
 
class X {
   private final ReentrantLock lock = new ReentrantLock();
   // ...
 
   public void m1() { 
     lock.lock();  // block until condition holds
     try {
       // ... method body
     } finally {
       lock.unlock()
     }
   }
   public void m2() { 
     lock.lock();  // block until condition holds
     try {
       // ... method body
     } finally {
       lock.unlock()
     }
   }
 
 }

Pour les Semaphore : http://java.sun.com/j2se/1.5.0/docs/...Semaphore.html
Attention ! Les sémaphores et les verrous sont bien deux concepts distinct et ne doivent pas être mélangé.