Discussion :

[difficiledetrouver1pseudo]

bonjour,

je cherche le moyen d'implementer un genre de watchdog en java.

je m'explique.

je commande via GPIB une alimentation. ce que j'aimerai c'est que si elle reste trop longtemps allumée, alors que l'on ne la commande plus depuis un certain temps, elle se coupe toute seule.

j'ai donc dans mon driver Java 2 methodes (entre autre) qui allume et eteingne l'alim.

ce que j'aimerai c'est lancer un watchdog lors de l'appel de la methode qui alume l'alim. si elle est deja allumé on réinitialiserai le watchdog.

lorsque le watchdog expire on appel la methode qui eteint l'alim.

je suppose que je dois implementer une classe appelons là "watchdog" qui herite de thread.

mais je n'ai pas trop l'abitude de jouer avec les threads et je voudrais connaitre les moyens de communication entre le thread (qui serait un objet Watchdog) et celui qui l'a lancé (qui serait le class driver_Alim).

merci de votre aide.

[ Modéré par Bulbo ]
Ajout d'un tag dans le titre
Les Règles du Forum

[herve91]

Tu trouveras ton bonheur dans la classe java.util.Timer

[difficiledetrouver1pseudo]

merci je vais voir ca.

[difficiledetrouver1pseudo]

bon me revoila avec mon watchdog.

voici ce que j'ai fait :

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
/**
 * 
 */
package Materiel.TTi;
 
/**
 *
 */
public class watchdog implements Runnable{
 
	int Duree;
	int Time_Actuel;
 
	Thread t;
 
	/**
         *  Duree en seconde
         */
	public watchdog(int Duree) {
		this.Duree = Duree;
 
		t = new Thread(this);
 
		this.Duree = Duree;
		Time_Actuel = 0;
 
		t.start();
	}
 
	public void run(){
 
		try {
			while (Time_Actuel < Duree) {
				Thread.sleep(1000);
				Time_Actuel++;
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
 
		// action à effectuer
		t=null;
	}
 
	/*
	 * reinitialise le watchdog
	 */
	public void Reinit(){
		Time_Actuel = 0;
	}
 
	/**
         * @param args
         * @throws InterruptedException 
         */
	public static void main(String[] args) throws InterruptedException {
		System.out.println("start");
		watchdog W = new watchdog(5);
 
		while(W != null){
			Thread.sleep(1000);
			System.out.println(W.Time_Actuel);
		}
 
		System.out.println("stop");
 
	}
}

mais bon j'en suis pas très satisfait pour le moment.

j'ai regardé la class java.util.Timer mais elle ne permet que de lancer à un instant t plus tard une méthode.

moi ce que je voudrais c'est pouvoir reinitialiser cette intervalle t si besoin. ainsi la méthode serait de nouveau retardée de t.

le même principe qu'un watchdog en fait. temps qu'il n'est pas expiré rien ne se passe. sinon il execute une gestion.

son expiration est du au fait qu'il n'est pas reinitialisé assez souvent.

pour revenir à mon code 2 problemes se posent :

comment faire pour que cet objet se detruisse à la fin de sa vie?
est ce que c'est vraiment genant de ne pas le detruire?

est-il possible de passer en parametre la méthode à executer à l'expiration du watchdog?

-----------

j'ai une deuxième méthode pour realiser cette fonction à l'aide de la class java.util.Timer.

je créé une class dérivant de Timer qui declenche mon action à retardement.

lors que j'allume mon alim, je crée un objet de cette class.

si cet objet existe deja lors de l'appel à la methode qui allum l'alim, je detruis l'objet pour le recréer. ainsi il sera reinitialisé.

est ce que cette solution est meilleur pour vous que la premiere?

ce qui m'embette un peu c'est que je detruis pour reconstruire (made in USA désolé...).

la méthode qui allume l'alim peut se repeter très très souvent. je ne voudrais pas ralentir inutilement mon algo qui tourne autour juste pour faire cette opération.[/i]

[bulbo]

Voici une classe qui fait ce que tu veux je pense .. en plus elle ne devrait pas trop bouffer de CPU:

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
public class WatchDog extends Thread
{
 
  private long _maxDelay;
  private long _lastDate;
 
  private GPIBConnection _watchedObj;
 
  public WatchDog(long aMaxDelay, GPIBConnection aGPIB)
  {
    _maxDelay = aMaxDelay;
    _lastDate = System.currentTimeMillis();
    _watchedObj = aGPIB;
    start();
  }
 
  public void run()
  {
    while(true)
    {
      long d = System.currentTimeMillis();
      if ((d - _lastDate) > _maxDelay)
      {
        _watchedObj.close();
        break;
      }
      try
      {
        synchronized(this)
        {
          this.wait(_maxDelay - d + _lastDate);
        }
      }
      catch (Exception e)
      {}
    }
  }
 
  public synchronized void reInit()
  {
    _lastDate = System.currentTimeMillis();
    notifyAll();
  }

N'hesite pas si qq chose ne marche pas ou si tu ne comprends pas tout

[Edit]
Et si tu veux un WatchDog plus generique, tu peux passer en argument du constructeur un Object et un nom de methode .. seul inconvenient tu ne peux pas passer d'arguments a ta methode .. et utiliser la reflection pour appeler la methode.
[/Edit]

Bulbo

[Oui-Oui MB]

Tu peux aussi regarder du côté de JDring ou, beaucoup plus étoffé, Quartz...

[difficiledetrouver1pseudo]

super j'ai testé ca fonctionne.

merci Oui-Oui MB j'ai regardé ce que tu m'as dis mais je pense que je vais rester sur le code de Bulbo.

le voici un peu 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
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
package Materiel.TTi;
 
import Materiel.Alimentation;
 
 
/**
 *
 */
 
public class watchdog extends Thread {
 
	private long _maxDelay;
	private long _lastDate;
	private Alimentation Alim;
 
	/**
         * delay en seconde
         * @throws Exception 
         */
	public watchdog(long aMaxDelay, Alimentation Alim) throws Exception {
		_maxDelay = aMaxDelay*1000;
		_lastDate = System.currentTimeMillis();
		this.Alim = Alim;
		// pour le test
		Alim.Open_Output();
		// ------------
		start();
	}
 
	public void run() {
		while (true) {
			long d = System.currentTimeMillis();
			if ((d - _lastDate) > _maxDelay) {
				try {
					Alim.Close_Output();
				} catch (Exception e) {
				}
				break;
			}
			try {
				synchronized (this) {
					this.wait(_maxDelay - d + _lastDate);
				}
			} catch (Exception e) {
			}
		}
	}
 
	public synchronized void reInit() {
		_lastDate = System.currentTimeMillis();
		notifyAll();
	}
 
	/**
         * @param args
         * @throws Exception 
         */
	public static void main(String[] args) throws Exception {
		System.out.println("start");
		watchdog W = new watchdog(5, new Alimentation(11));
 
		while (W != null) {
			Thread.sleep(1000);
		}
 
		System.out.println("stop");
	}
}

ca fonctionne mais etant très chiant j'aurais d'autre question.

1) est ce que après la fin de ca méthode run le thread est detruit ou il faut le faire "manuellement"?

2) comment savoir quant un thread est vivant ou non?

3) comment passer une methode en paramètre d'un constructeur?

comme on peut le voir la methode Close_Output de la class alimentation ne contient pas de parametre (elle peut lever une exception toutefois).

j'aimerai, au lieu de passer l'objet Alimentation, juste passer la methode Close_Output.

la methode Open_Output deviendrai :

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
 
package Materiel;
 
import Materiel.TTi.Ql355P_GPIB;
 
/**
 *
 */
public class Alimentation extends Ql355P_GPIB {
 
	Watchdog Arret_Auto;
 
	...
 
	/*
	 * valide la sortie
	 */ 
	public void Open_Output() throws Exception{
		if (Marche)
			return;
 
		Port_GPIB.Write("OP1 1");
		Thread.sleep(20);			// pour permettre la stabilisation de la sortie
		if ("Arret_Auto est actif"){
			Arret_Auto.reInit();
		else
			Arret_Auto = new Wachdog(60, Close_Output());
 
		Marche = true;
	}

comme on le vois il me faut savoir si l'arret autamatique est actif on non.

d'ou la question 1 et 2.

[bulbo]

Un thread s'arrete a la fin de sa methode run, c'est a dire qu'il n'est plus actif dans la VM. Apres cela reste un objet c'est a dire qu'il sera detruit par le Garbage collector uniquement si il n'y a plus de reference dessus.

Pour savoir si un thread est vivant il y a isAlive mais c'est pas super propre tu as raison j'ai neglige ce point dans mon algo.

Si tu peux attendre cet apres-midi je te propose une meilleur version ..

Pour ce qui est de passer une methode en parametre, ce n'est pas aussi simple.

Tu peux passer un Object et un String qui serait le nom de la methode ou un Object et une java.lang.reflect.Method sauf si la methode est static dans ce cas l'objet Method suffit.

Exemples:

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
public void test(Object anObject, String aName)
{
  Method m = anObject.getClass().getMethod(aName);
  if (null != m)
  {
    m.invoke(anObject, null);
  }
}
 
// methode non static
public void test(Object anObject, Method aMethod)
{
    aMethod.invoke(anObject, null);
}
 
// methode static
public void test(Method aMethod)
{
   aMethod.invoke(null, null);
}

[difficiledetrouver1pseudo]

merci beaucoup de ta réponse.

j'avais trouvé la méthode isalive mais comme tu dis que c'est pas très propre je vais attendre ta solution.

pas de probleme pour attendre je ne suis pas pressé quand j'attend de l'aide (juste impatient )

merci encore pour ton aide.

[bulbo]

Bon si j'ai bien compris ton Alimentation peut etre fermee et reouverte plusieurs fois et tu ne veux pas etre oblige de relancer un WatchDog a chaque fois.

Voici une nouvelle version du WatchDog et un exemple d'Alimentation qui va avec.
L'Alimentation a d'office un WatchDog qui existe tant que l'objet Alim existe.

Le WatchDog est stoppe a la destruction de l'objet Alimentation par le GC et dans ce cas essaye de fermer l'output.

Quand le delai est depasse le WatchDog fait un closeOutput et se bloque sur un wait et ne consomme plus de CPU. Un appel a reInit le reveil et il remet en place le delai avant de faire un closeOutput.

Remarque: j'ai renomme les variables suivant les recommandations de Sun.. c'est un standard de facto en java et c'est toujours mieux de le respecter ca aide les autres a mieux comprendre ton 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
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
 
public class WatchDog extends Thread
{
 
  private long _maxDelay;
 
  private long _lastDate;
 
  private boolean _isClosed;
 
  private Alimentation alim;
 
  /**
   * delay en seconde
   * 
   * @throws Exception
   */
  public WatchDog(long aMaxDelay, Alimentation anAlim)
  {
    _maxDelay = aMaxDelay * 1000;
    _lastDate = -1;
    _isClosed = false;
    alim = anAlim;
    start();
  }
 
  public synchronized void close()
  {
    _isClosed = true;
    this.notifyAll();
  }
 
  public void run()
  {
    while (true)
    {
      synchronized(this)
      {
        try
        {
          long d = System.currentTimeMillis();
 
          if (_isClosed || ((-1 != _lastDate) && ((d - _lastDate) > _maxDelay)))
          {
            try
            {
              alim.closeOutput();
            }
            catch (Exception e)
            {}
 
            _lastDate = -1;
          }
 
          if (_isClosed)
          {
            break;
          }
 
          if (-1 == _lastDate)
          {
            this.wait();
          }
          else
          {
            this.wait(_maxDelay - d + _lastDate);
          }
        }
        catch (Exception e)
        {}
      }
    }
  }
 
  public synchronized void reInit()
  {
    _lastDate = System.currentTimeMillis();
    this.notifyAll();
  }
 
  /**
   * @param args
   * @throws Exception
   */
  public static void main(String[] args) throws Exception
  {
    System.out.println("start");
    Alimentation alim = new Alimentation();
 
    // utilisation de alim ici
 
    alim = null;
    System.out.println("stop");
  }
}

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
 
public class Alimentation
{
  private WatchDog arretAuto;
 
  private boolean marche;
 
  public Alimentation()
  {
    marche = false;
    arretAuto = new WatchDog(60, this);
  }
 
  public void openOutput() throws Exception
  {
    arretAuto.reInit();
 
    if (marche)
    {
      return;
    }
 
    //Port_GPIB.Write("OP1 1");
    Thread.sleep(20);         // pour permettre la stabilisation de la sortie
 
    marche = true;
  } 
 
  public void closeOutput() throws Exception
  {
    marche = false;
  }
 
  protected void finalize() throws Throwable
  {
    super.finalize();
    arretAuto.close();
  }
}

Bonne chance,

Bulbo

[Wookai]

Remarque: j'ai renomme les variables suivant les recommandations de Sun.. c'est un standard de facto en java et c'est toujours mieux de le respecter ca aide les autres a mieux comprendre ton code

J'ai juste une question. Ca n'a rien à voir avec le thread, donc désolé de polluer, mais je me permets de relever ta remarque, bulbo. Je fais de plus en plus de java, et j'essaie de bien respecter les conventions. C'est vrai que c'est bien mieux si n'importe qui peut s'y retrouver du premier coup d'oeil dans le script d'un autre !

J'ai vu à plusieurs reprises des noms de variables commencer par _, et je me demandais si c'était une convention. Vu qu'il y en a dans ton script ci-dessus et que tu dis respecter les conventions de Sun, je suis allé voir sur leur site de quoi il retournait ! Voilà ce que j'ai trouvé (http://java.sun.com/docs/codeconv/ht...doc8.html#367) :

Except for variables, all instance, class, and class constants are in mixed case with a lowercase first letter. Internal words start with capital letters. Variable names should not start with underscore _ or dollar sign $ characters, even though both are allowed.

D'après ce que mon anglais me dit, il ne faudrait pas commencer un nom de varialbe par un _, non ?

[bulbo]

Dans les grandes lignes je respecte les conventions de Sun .. mais j'ai horreur des accolades ouvrantes en fin de ligne par exemple..

Mes variables privees commencent par _ .. ca gene pas la lisibilite, ca me permet de savoir immediatement si une variable est privee ou locale..
Je devrais pas je sais mais j'aime pas les trucs genre mMaVariable, c'est tout.

En plus des conventions de Sun, je me suis aussi inspire de ce document: http://www.ambysoft.com/javaCodingStandards.html

Et apres c'est ma sauce a moi de toute facon mais a part ce _ je ne pense pas enfreindre d'autres regles ..

Bulbo

[Wookai]

Ok, ok ! Je ne critiquais pas, loin de moi cette idée ! C'était "juste pour savoir"... Donc les variables commençant par _ sont les variables privées, c'est ça ?

[bulbo]

Dans un code provenant de moi: Oui

Bulbo

[difficiledetrouver1pseudo]

je viens de tester le code et c'est parfait.

je l'ai juste un peu modifié pour permettre de passer la methode en paramètre du contructeur du Watchdog comme tu me l'as decrit Buldo.

je met tout le code pour ce que ca pourrai interresser.

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
 
 
WatchDog.java
 
/**
 * 
 */
package Materiel.TTi;
 
import java.lang.reflect.Method;
 
/**
 *
 */
public class WatchDog extends Thread {
 
	private long _maxDelay;
	private long _lastDate;
	private boolean _isClosed;
	private Object _anObject;
	private String _aMethod;
 
	/** 
         * delay en seconde 
         * 
         * @throws Exception 
         */
	public WatchDog(long aMaxDelay,Object anObject, String aMethod{
		_maxDelay = aMaxDelay * 1000;
		_lastDate = -1;
		_isClosed = false;
 
		this._anObject = anObject;
		this._aMethod = aMethod;
 
		start();
	}
 
	public void run() {
		while (true) {
			synchronized (this) {
				try {
					long d = System.currentTimeMillis();
 
					if (_isClosed ||
							((-1 != _lastDate) && ((d - _lastDate) > _maxDelay))){
						try {
							Method m = _anObject.getClass().getMethod(_aMethod,
									null);
							if (null != m)
								m.invoke(_anObject, null);
 
						} catch (Exception e) {}
 
						_lastDate = -1;
	}
 
					if (_isClosed)
						break;
 
					if (-1 == _lastDate)
						this.wait();
					else
						this.wait(_maxDelay - d + _lastDate);
 
				} catch (Exception e) {}
			}
		}
	}
 
	public synchronized void reInit() {
		_lastDate = System.currentTimeMillis();
		this.notifyAll();
	}
 
	public synchronized void close() {
		_isClosed = true;
		this.notifyAll();
	}
}

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
 
 
Ql355P_GPIB.java
 
package Materiel.TTi;
 
import dao.GPIB;
 
public class Ql355P_GPIB {
 
	protected boolean Marche = false;
 
	private WatchDog Arret_Auto;
 
 
	public Ql355P_GPIB(int Adresse_GPIB) throws Exception {
		Port_GPIB = new GPIB(Adresse_GPIB);
		// se connecte au périférique
		Port_GPIB.Connect();
		// verifie si c'est bien un périférique de type HP3458 qui est
		// à l'adresse indiqué
		Check_Divice();
 
		// gestion de l'arret automatique
		Arret_Auto = new WatchDog(30, (Object) this, "Close_Output");
	}
 
	/*
	 * valide la sortie
	 */ 
	public void Open_Output() throws Exception{
		// lancement un watchdog qui eteindra l'alim
		// si elle n'est pas utilisée depuis 5 mins
		Arret_Auto.reInit();
 
		if (Marche)
			return;
 
		Port_GPIB.Write("OP1 1");
		System.out.println("Sleep");
		Thread.sleep(5);			// pour permettre la stabilisation de la sortie
 
		Marche = true;
	}
 
	/*
	 * invalide la sortie
	 */ 
	public void Close_Output() throws Exception{
		if (!Marche)
			return;
 
		Port_GPIB.Write("OP1 0");
 
		Marche = false;
	}
 
	public void finalize() throws Throwable { 
	    super.finalize(); 
	    Arret_Auto.close(); 
	  } 
 
 
}

pour ce qui est du formatage du code j'ai pratiqué grand nombre de language et à chaque fois le concepteur essais d'imposer une nouvelle convension.

ca devient très lourd de suivre la mode perso. de plus ca fait que 2 moins que j'ai decouvert java.

mais je me surveille quand j'ai le temps . je sais que c'est plus lisible si tout le monde suit la même ecriture.


merci pour ce coup de pousse.

a+ surment

[bulbo]

Juste pour chipoter sur la syntaxe

Je mets _ devant mes variable privees et a ou an qqchose pour les parametres d'une methode uniquement. Et si c'est une liste ou un tableau je mets un s ou mieux je mets List a la fin de la variable.

Par exemple aClientList sera le parametre et _clientList serait pour la variable privee

Bulbo

[difficiledetrouver1pseudo]

ok je note c'est vrai que c'est pratique pour la lisibilité du code.