Discussion :

[Akamura]

Bonjour à toutes et à tous,

Voilà j'essaye de concevoir un chronomètre basé sur la méthode nanoTime(), après un premier essai concluant j'ai voulu implémenter un système de pause et de reprise, et là je suis confronté à de violents StackOverflowError dès que j'essaye de le démarrer. Je pense que j'ai passé trop de temps dessus et j'aurais besoin d'un avis externe pour m'éclairer.

Pour info je fais appel aux méthodes suivantes via un Timer paramétré avec un délai d' une milliseconde.

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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
 
public class Chrono {
 
 
	public Chrono() {
 
	}
	private final long nsParTick = 100;
	private final long nsParMs = 1000000;
	private final long nsParSs = 1000000000;
	private final long nsParMm = 60000000000L;
	private final long nsParHh = 3600000000000L;
 
	private long startMillis = 0;
	private long startSeconds = 0;
	private long startMinutes = 0;
	private long startHours = 0;
	private long inter = 0;
 
 
	private long debut = 0;
	private long arreter = 0;
	private boolean auTravail = false;
	private boolean hasBeenStopped = false;
 
	public boolean getAuTravail()
	{
		return this.auTravail;
	}
 
 
	public boolean getHasBeenStopped()
	{
		return this.hasBeenStopped;
	}
 
 
 
 
	public void demarrer() {
		this.debut = System.nanoTime();
		this.startSeconds = debut;
		this.startMinutes = debut;
		this.startMillis = debut;
		this.startHours = debut;
		this.auTravail = true;
	}
 
	public void arreter() {
		this.arreter = System.nanoTime();
		this.startSeconds = arreter;
		this.startMinutes = arreter;
		this.startMillis = arreter;
		this.startHours = arreter;
		this.inter = arreter - debut;
		this.hasBeenStopped = true;
	}
 
	public void reinitialiser() {
		this.inter = 0;
		this.debut = 0;
		this.arreter = 0;
		this.auTravail = false;
		this.hasBeenStopped = false;
	}
 
	public void redemarrer()
	{
		this.auTravail = true;
	}
 
 
	public long getNbTicks() {
		long nbTicks;
		if (auTravail) {
			nbTicks = inter + (System.nanoTime() - debut);
		}
		else {
			nbTicks = (arreter - debut);
		}
		return nbTicks / nsParTick;
	}
 
 
 
	public long getNbMilliseconds() {
		long nbMillis;
		if (auTravail) {
 
			nbMillis = inter + (System.nanoTime() - startMillis);
			if (nbMillis < 1000000000)
			{
				return nbMillis / nsParMs;
			}
			startMillis = System.nanoTime();
			getNbMilliseconds();
 
		}
		else {
			nbMillis = (arreter - startMillis);
		}
 
		return nbMillis / nsParMs;
	}
 
 
	public long getnbSeconds() {
		long nbSec;
		if (auTravail) {
			nbSec = inter + (System.nanoTime() - startSeconds);
			if (nbSec < 60000000000L)
			{
				return nbSec / nsParSs;
			}
			startSeconds = System.nanoTime();
			getnbSeconds();
		}
		else {
			nbSec = (arreter - startSeconds);
		}        
		return nbSec / nsParSs;
	}
 
 
 
	public long getNbMinutes() {
		long nbMin;
		if (auTravail) {
			nbMin = inter + (System.nanoTime() - startMinutes);
			if (nbMin < 3600000000000L)
			{
				return nbMin / nsParMm;
			}
			startMinutes = System.nanoTime();
			getNbMinutes();
		}
		else {
			nbMin = (arreter - startMinutes);
		}        
		return nbMin / nsParMm;
	}
 
 
 
	public long getNbHours() {
		long nbHours;
		if (auTravail) {
			nbHours = inter + (System.nanoTime() - startHours);
		}
		else {
			nbHours = (arreter - startHours);
		}        
		return nbHours / nsParHh;
	}
 
 
}

Merci d'avance à tous ceux qui pourraient me venir en aide.

[tchize_]

Code :

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

1
2
3
4
5
6
7
8
9
10
11
public long getNbMilliseconds() {
		long nbMillis;
		if (auTravail) {
 
			nbMillis = inter + (System.nanoTime() - startMillis);
			if (nbMillis < 1000000000)
			{
				return nbMillis / nsParMs;
			}
			startMillis = System.nanoTime();
			getNbMilliseconds();

tu appelle récursivement sans condition d'arrêt getNbMilliseconds.

[Akamura]

Merci pour votre intervention.

Ce qui m'étonne, c'est que cet appel récursif ne pose aucun problème tant que je n'ai pas arrêté et relancé le chronomètre au temps où il s'était arrêté.

Sachant que je ne fais appel à cette méthode récursive qu'une fois par seconde au maximum.

Peut-être que lorsque je relance le chronomètre après l'avoir mis en pause il ne rentre plus dans le if et rentre donc dans une chaîne récursive sans fin ?

J'ai du mal à cerner le problème exactement.

En tous cas merci pour votre intervention !

[tchize_]

Merci pour votre intervention.

Ce qui m'étonne, c'est que cet appel récursif ne pose aucun problème tant que je n'ai pas arrêté et relancé le chronomètre au temps où il s'était arrêté.

Un fois que tu as dépassé une certain valeur (cf ton test) tu passe en récursif, mais il n'y a pas de raison pour que la valeur diminue dans la récursion.


De plus, je vois pas pourquoi tu te complique la vie avec ces technique compliquée. Un chronomètre, c'est juste un calcul de différence :/

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
long debut,ecoule;
boolean enRoute;
 
public void demarrer(){
    enRoute = true;
    debut = System.nanoTime();
}
protected void getCurrentRun(){
    return System.nanoTime() - debut;
}
public long stop(){
    enRoute = false;
    return ecoule +=getCurrentRun();
}
public long getValue(){
    if (enRoute)
      return ecoule + getCurrentRun();
    else
      return ecoule;
}

[Akamura]

Bonjour,

Merci pour votre réponse.

En fait le problème réside dans le fait que je souhaite afficher le temps écoulé dans un format compréhensible, avec votre exemple ( merci au passage d'avoir prit le temps de le rédiger ), je ne vais avoir qu'un nombre extrêmement grand et peu lisible correspondant au nanosecondes écoulées.

Les if que j'utilise dans mes différentes méthodes permettent de simuler le comportement normal d'un chronomètre ( de 0 à 999 millisecondes la case correspondante aux millisecondes augmente puis repasse à 0 et ainsi de suite).

De même pour pour les secondes, minutes, etc.

Ma méthode n'est surement pas idéal mais disons que lors du premier lancement le temps défile de manière compréhensible et la latence induite par la réinitialisation des millisecondes toutes les secondes est négligeable.

En revanche le redémarrage pose beaucoup plus de soucis.

Merci pour votre aide.

[tchize_]

Rien ne t'empeche de créer une méthode qui retourne, en gros

Code :

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

return new MonTime(getValue())

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
 
public class MonTime {
    public final long nano;
    public final long seconds;
    public final long minutes;
    public final long heures;
    public MonTime(long timestamp){
       nano = timestamp % 1000000000;
       long reste = timestamp /1000000000;
       seconds  = reste % 60;
       reste /=60;
       minutes = reste % 60;
       reste /= 60;
       heures = reste;
    }
}

de toutes façons, l'appel à System.nanoTime() n'a rien à voir avec les méthodes qui permetteraient de ventiler en heure minute seconde millièmes nano Garde tes logiques séparées, ça gardera un code clair et maintenable.

[Akamura]

Merci pour votre réponse.

Je vais essayer de suivre vos conseils même si je ne vois pas vraiment la logique à suivre en utilisant votre méthode.

Je vais essayer de me pencher dessus cette après-midi.

Merci et bonne après-midi.

[tchize_]

Je vais essayer de suivre vos conseils même si je ne vois pas vraiment la logique à suivre en utilisant votre méthode.

Séparer la partie buisness (le suivi du temps en nano secondes) de la partie présentation (splitter le nano en milli/seconde/minutes/heures) + évter les erreur en multipliant les codes de calculs.