Discussion :

[difficiledetrouver1pseudo]

petite question d'optimisation.

j'ai besoin de créer un thread pour faire une mesure sur un instrument car cette mesure peut prendre du temps. (rq : je commande cette instrument via le bus GPIB interfacé avec java)

j'ai donc naturellement fait ceci comme suit :

Code :

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

1
2
3
4
5
6
7
8
/*
	 * lie une donnée
	 */
	public void Get_Mesure(double[] Mesure) throws Exception{
		Attente_Mesure = true;
 
		new Lecture_Mesure(Mesure);		
	}

avec la class Lecture mesure suivante :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
		public void run(){
			Attente_Mesure = true;
 
			try {
				Mesure[0] = Double.parseDouble(Port_GPIB.Read());
			} catch (Exception e) {
				e.printStackTrace();
			}
 
			Attente_Mesure = false;
		}

cette class est privé car elle est interne au paquetage contenant la methode Get_Mesure().

comme on le vois la mesure doit retourner un double.

j'ai donc fait un passage par reference (double[])

j'appelle donc ma methode comme suit :

Code :

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

1
2
3
4
 
		double Mesure[] = new double[1];
 
		Le_Multimetre.Get_Mesure(Mesure);

es ce que cette methode est correcte?

voyez vous une autre solution plus adaptée?

merci

[keil]

normalement oui c'est correct mais y'a une autre solution
tu déclare en public une methode qui te donnera le la valeur de ta variable Mesure et tu transmet l'objet mere a ta thread. Par exemple:

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
 
class Base
{
  double Mesure;
  public Base()
  {
    (new ProcessusParallele(this)).start();
  }
 
  public double getValue()
  {
    return Mesure;
  }
}
 
class ProcessusParallele extends Thread
{
  Base base;
  public ProcessusParallele(Base b)
  {
    base = b;
  }
 
  public void run()
  {
    System.out.println("nb: "+base.getValue());
  }
}

[difficiledetrouver1pseudo]

le probleme avec ta solution c'est que la methode Get_Mesure prend en parametre la variable qui doit contenir le resultat.

cette methode est appelée à different endroit de mon programme et la destination n'est pas toujours la même.

donc je ne peut pas faire comme tu le dis.

[adiGuba]

Salut,


Ton code devrait fonctionner (tu as un problème dessus ou pas ?). Par contre je ne trouve pas la conception très Object (le fait de passé un tableau de 1 élément pour récupérer un Object...).




Si tu utilises Java 5.0 tu pourrais peut-être utilisé la nouvelle API de concurrence et l'interface Callable<T> :

Code :

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

1
2
3
4
5
6
public class LectureMesure implements Callable<Double> {
 
	public Double call() throws Exception {
		return Double.parseDouble(Port_GPIB.Read()); 
	}
}

Que tu executes de la manière suivante :

Code :

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

1
2
ExecutorService executor = Executors.newCachedThreadPool();
Future<Double> resultat = executor.submit(new LectureMesure());

Ensuite il te suffit d'utiliser les méthodes de l'interface Future<T> pour savoir si le thread est terminé, récupéré la valeur de retour avec get(), etc...



Sinon avec une version antérieur de Java tu peux simuler ce comportement avec Runnable :

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 LectureMesure implements Runnable {
 
	Double result = null;
	Exception exception = null;
 
	public void run() {
		try {
			result = Double.parseDouble(Port_GPIB.Read()); 
		} catch (Exception e) {
			this.exception = e;
		}
	}
 
	public double getDouble () throws Exception {
		if (this.exception != null) {
			throw this.exception;
		}
		if (this.result == null) {
			throw new Exception ("Thread en cours...");
		}
		return result.doubleValue();
	}
}

a++

[difficiledetrouver1pseudo]

Salut,


Ton code devrait fonctionner (tu as un problème dessus ou pas ?). Par contre je ne trouve pas la conception très Object (le fait de passé un tableau de 1 élément pour récupérer un Object...).

j'ai un probleme de rapidité d'execution mais je pense pas que cela vienne de ce bout de code.
donc je dirais que oui pour le moment.

Si tu utilises Java 5.0...

non j'utilise Java 4.2.

la deuxieme solution n'est pas très adapté à mon probleme je pense.

ce que je cherche c'est lire une donné (différé du fait de temps de capture) pour la stocker dans une variable.

je ne veux pas le faire avec une procedure bloquante pour des probleme de temps. je met environ 25ms pour capturer un mesure. sachant que je lance cette mesure toute les 40ms si j'ai une procedure bloquante je ne pense le faire que toute les 40ms+25ms.

donc voilà pourquoi j'ai créer un thread pour la mesure qui peut se faire donc durant la période de 40ms qui suit pour la mesure suivante.

petit schema peut être :

Code :

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

1
2
3
4
5
6
7
8
solution 1 sans thread :
mesure1										mesure2									...
|--------40ms---------|+|---25ms---| |--------40ms---------|+|---25ms---|
 
solution 2 avec thread :
mesure1						mesure2							...
|--------40ms---------| |--------40ms---------|
								|---25ms---|				|---25ms---|

voici un extrait du 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
23
24
25
 
 
 	double Mes[][] = new double[Le_Produit.Nb_Pin][1];
 
 	for (int Num_Seq = 0; Num_Seq < Le_Produit.Nb_Pin; Num_Seq++){
			// simule la synchro du mux 
 			Le_Multiplexeur.Send_Trig();
			Thread.sleep(40);
 
			// prend une mesure
			Le_Multimetre.Get_Mesure(Mes[Num_Seq]);
 
		}
 
		// attente la fin des mesures
		Le_Multimetre.Wait_Mesure();
 
		// traitement des resultats
		for (int Num_Seq = 0; Num_Seq < Le_Produit.Nb_Pin; Num_Seq++){
			Mesure[(Le_Multiplexeur.Num_Canal_Scan[Num_Site][Num_Seq])]
		       [Num_Pass] =
		    	   new double[] {Mes[Num_Seq][0],
					((Mes[Num_Seq][0] < 0 | Mes[Num_Seq][0] > Le_Test.Get_Max(
						(Le_Multiplexeur.Num_Canal_Scan[Num_Site][Num_Seq]))) ? 2:1) };
		}

je ne peut pas faire de getValue qui me forcerait à attendre la valeur. ce qui rendrait le thread inutile.

es ce que je suis plus clair là ?

[adiGuba]

L'interface Runnable est concus pour être utilisé dans un Thread... donc tu peux faire un code similaire...

Et une fois que tu as lancé tous les threads tu attends qu'ils soient finis pour lire les valeurs (un peu comme tu sembles déjà le faire avec Le_Multimetre.Wait_Mesure(); ).

Mais encore une fois ta solution n'est pas fausse...

a++

PS : tu devrais utiliser les règles de nommage standard de Java (pas de _ dans les noms de classe/méthode/variable, première lettre en majuscule pour les classe, et en minuscule pour les autres, par exemple Get_Mesure() --> getMesure() ...)

[difficiledetrouver1pseudo]

bonjour,

oui c'est ce que je fait avec Wait_Mesure(). j'atend que la derniere mesure soit finie.

toutefois j'aurai une question. pour des questions de securité je voudrai m'assurer que 2 instances de thread ne soit pas existante en même temps. le but est de voir si il y a un problème de synchro du à un mesure qu'il se serait tardé sur le chemin du PC.

comme tu as du le comprendre, il doit n'y avoir qu'un thread lancé toute les 40ms. et ce thread vie qu'une 30ms au maximum le tems de lecture de la mesure. donc normalement quand je lance le suivant le precedent n'existe plus et a deja retourné la mesure.

mais bon ca c'est la théorie. je voudrais m'asssurer de ce bon fontionnement.

voir ralonger les 40ms pour attendre la mesure.

j'ai créé une variable Attente_Mesure qui est à true lors qu'un thread attent une mesure. mais bon il y a un probleme de resource partagé sur cette variable si plusieurs thread existe. donc avant de lancer je test cette variable.

mais bon tu comprends que c'est pas très bon. du fait de la concurrence des tache il se peut qu'il y a un probleme sur le test de cette variable.

je ne suis pas très bon en thread Java et surtout en synshronisation. peux tu m'en dire plus sur ce sujet?

merci.

-----
PS : Pour les régles de nomage je sais que je ne suis pas à la page. (des reste d'ADA ne s'efface pas vite)

mais je ne veux pas modifier le style en cour de projet. c'est plus difficle à relire par la suite.

j'ai plus de 50 class. je ne veux pas tout reprendre. tu me comprendras .

mais pour mes autres projets en cours j'ai adopté les régles Java.

[difficiledetrouver1pseudo]

voici ce que j'ai fait mais ca focntionne pas :

Code :

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

1
2
3
4
5
6
	public void Get_Mesure(double[] Mesure) throws Exception{
 
		Wait_Mesure();
 
		new Lecture_Mesure(Mesure);		
	}

Code :

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

1
2
3
	public void Wait_Mesure(){
		while(Attente_Mesure){};
	}

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
	private class Lecture_Mesure extends Thread {
 
		double Mesure[];
 
		public Lecture_Mesure(double[] Mesure){
			this.Mesure = Mesure;
			this.start();
		}
 
 
		public void run(){
 
			Attente_Mesure = true;
 
			try {
				Mesure[0] = Double.parseDouble(Port_GPIB.Read());
			} catch (Exception e) {
				e.printStackTrace();
			}
 
			Attente_Mesure = false;
		}
	}

[adiGuba]

Salut,


Le problème vient surement du code suivant :

Code :

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

1
2
3
	public void Wait_Mesure(){
		while(Attente_Mesure){};
	}

En effet, afin d'optimiser le traitement, la JVM ne relit pas forcément la valeur de Attente_Mesure à chaque itération étant donné que cette valeur n'est jamais modifié dans la boucle... Pour forcer la JVM à relire la valeur à chaque fois tu dois utiliser le mot-clef volatile sur la déclaration de ta variable (plus d'info dans la FAQ : Que signifie le mot-clé volatile ?).

Mais ce type d'attente n'est pas terrible car elle utilise beaucoups de temps processus pour vérifier à chaque fois la valeur de la variable... On appelle cela une attente active...
Il serait preferable d'utiliser un sleep() dans la boucle pour diminuer les vérifications...

toutefois j'aurai une question. pour des questions de securité je voudrai m'assurer que 2 instances de thread ne soit pas existante en même temps. le but est de voir si il y a un problème de synchro du à un mesure qu'il se serait tardé sur le chemin du PC.

Là je ne comprend plus trop pourquoi tu utilises des Threads...

Si tu ne dois avoir qu'une seule lecture à la fois et que tu attends la fin de celle-ci pour lancer la suivante, tu n'as pas besoin d'utiliser de Thread... Un traitement séquentiel devrait faire l'affaire...

a++

PS : pour les règles de nommage je parlais bien entendus pour tes prochains codes

[difficiledetrouver1pseudo]

j'ai mis un sleep comme conseilé. c'est vrai que c'est pas terrible les attente active. masi là je plus beaucoup de temps pour faire mieux.

Si l'utilité du thread est justifier par le fait que durant l'activité du thread, le programme "principal" continue son execution. j'ai mis un sleep(40); pour ne pas compliquer mes explixcations mais il fat des choses en parallèle durant c'est 40ms, ne serais ce que pour relancer une mesure .

rappel :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
solution 1 sans thread : 
              mesure1                              mesure2                           ... 
Prog_Princ : |--------40ms---------|+|---25ms---| |--------40ms---------|+|---25ms---| 
 
 
solution 2 avec thread : 
                  mesure1                  mesure2                     ... 
Prog Principal : |--------40ms---------| |--------40ms---------| 
Thred lecture  :                         |---25ms---|            |---25ms---|
 
----------------------------------> temps