Décompte horaire

**vertebre** · 12/11/2015, 00h24

Bonsoir,

J'ai un objet A qui subit la fonction1 d'un objet B pour un temps donné, les attributs de l'objet A sont donc modifiés.
Une fois le temps arrivé à 0, j'applique une fonction2 qui réaffecte les valeurs initiales de l'objet A (fonction inverse de la fonction1).

voilà comment je compte concevoir ce truc:

-variable contenant le temps d'affectation de la fonction1 (120mn par exemple)
-à l'activation de l'objet B, on commence le décompte des 120mn
-une fois le décompte arrivé à 0, on affecte la fonction2.

Est ce la meilleur façon de voir les choses et comment faire et afficher ce décompte horaire en java svp ?

Bonne soirée,

**joel.drigo** · 12/11/2015, 10h57

Salut,

Déjà, il faut que tu définisses "affichage" : affiche où/comment ? En console ? Dans une fenêtre Swing ? Et puis que veux tu afficher ? Le décompte, c'est en minutes, en minutes/secondes... ?

Ensuite, à la base, tu peux utiliser la classe java.util.Timer et sa méthode scehdule() pour lancer la tâche de remise à zéro (attention le temps s'exprime en millisecondes. Si tu veux pouvoir afficher le décompte intermédiaire, quelque soit l'unité, cette méthode ne peux pas fonctionner directement : on programme la tâche et elle s'exécute lorsque le délai est achevé. On pourrait faire un thread qui boucle, jusqu'à ce que le temps soit achevé, et qui, sur une condition intermédiaire met à jour un affichage, du type :

Code pseudocode :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
tempstotal = 120 * 60 * 1000
tempsrestant = tempstotal
tempsdepart = System.currentTimeMillis()
tempsinter = temps
tempsactuel
tant que (tempactuel = System.currentTimeMillis())-tempsdepart < tempstotal
si tempactuel - tempsinter > 1000  // pour un décompte seconde par seconde (1000 ms)
   tempinter = tempsactuel
   tempsrestant  = tempsactuel - tempsdepart
   mettre à jour affichage décompte tempsrestant 
fin si
fin tant que

Ce n'est pas hyper précis, puisque l'exécution de ce code mets lui même du temps, mais ça peut le faire si tu n'as pas besoin de grande précision.

Tu peux également procéder avec deux java.util.Timer : un pour programmer la tâche de remise à zéro, et un qui décompte le temps (en utilisant la méthode scheduleAtFixedRate()). Le premier devra aussi arrêter le second (méthode cancel()).

**vertebre** · 16/11/2015, 14h30

Bonjour,

Le programme doit afficher le décompte dans une appli android, je pense choisir çà dans un textview.

Je voudrais un affichage de ce type:
1mn 59sec
1mn 58sec
1mn 57sec
...

Mais comme c'est un jeu j'ai besoin d'une précision relative. En effet si une personne utilise ce décompte sur un tel puissant celui ci durera moins longtemps que sur un téléphone moins puissant.
J'ai donc besoin soit d'une manière de mesurer le temps d'exécution de ce code en fonction de la machine, puis adapter le décompte et homogénéiser le temps de décompte sur les téléphones différents; soit d'une autre façon.

Qu'en penses tu ? vois tu une autre manière de voir ce problème ?

**joel.drigo** · 16/11/2015, 15h20

Envoyé par vertebre

Mais comme c'est un jeu j'ai besoin d'une précision relative. En effet si une personne utilise ce décompte sur un tel puissant celui ci durera moins longtemps que sur un téléphone moins puissant.
J'ai donc besoin soit d'une manière de mesurer le temps d'exécution de ce code en fonction de la machine, puis adapter le décompte et homogénéiser le temps de décompte sur les téléphones différents; soit d'une autre façon.

Non, c'est utopique de raisonner comme ça. Le temps de faire des adaptations en fonction de je sais pas quoi, temps qui dépend lui-même de plein de choses (vitesse du processeur, disponibilité des ressources, priorité des processus, etc), il faudra lui-même l'adapter, et donc prendre du temps, donc l'adapter etc.
Il n'y a pas de raison que le décompte soit différent selon l'appareil (le temps total d'exécution d'une tâche oui, le temps de rafraîchissement effectivement).

Le temps (en dépit de son aspect relatif que nous négligerons pour des raisons évidentes...) doit être considéré comme absolu dans ce type de calcul et surtout indépendant de ce qu'on fait comme tâche : ainsi, que ça prenne un retard ou une avance, lors d'un affichage, on s'en moque, parce que chaque affichage est traité de manière absolue (par rapport au début du processus, de ce qui a été déjà fait, et de ce qu'il reste à faire), et le temps de toute manière de rafraîchir l'affichage, tous les ajustements que tu pourras faire seront de toute façon caduques. Le but est d'éviter surtout les aberrations (dire qu'il reste une heure à attendre alors qu'il reste 1 seconde).

Par exemple, si le but est de faire un affichage de temps restant de transfert d'un fichier, on peut calculer ou estimer un nombre total d'octets à transférer, calculer régulièrement le temps depuis le début, en déduire la vitesse de traitement de chaque octet (ou groupe d'octets), à partir de la différence entre ce qui a été fait et ce qui doit être fait, déterminer le reste à faire, puis en déduire le temps restant, qui sera forcément une approximation, mais ça n'a normalement pas grande importance humainement on fait pas trop la différence et on s'en fout à la limite, à moins qu'on ait besoin d'une très grand précision dans un domaine très particulier (scientifique, genre astrophysique, ou vol spatial

), mais là, ça risque d'être plutôt complexe à garantir). Le calcul peut-être fait en parallèle, pour éviter d'influencer le temps d'exécution de la tâche principale (l'affichage lui étant forcément asynchrone).

**vertebre** · 16/11/2015, 21h48

En gros si j'ai bien compris tu me conseille de lancer vérifier régulièrement le temps restant par rapport à l'horaire où la tâche est lancée ? pour adapter le décompte si vraiment il y a un très gros écart ?

**joel.drigo** · 17/11/2015, 00h53

Il n'y a rien à vérifier : tu lances une tâche avec un délai de 120 minutes, et une autre avec une certaine fréquence (toutes les secondes si tu veux faire un décompte à la seconde) qui affiche le décompte, en comparant éffectivement le moment de départ de la tâche par rapport au moment actuel.

tâche de démarrage

Code pseudocode :

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

1
2
3
programmer tâche principale avec un délai de 120 minutes (java.util.Timer)
temps cible = temps actuel + 120 minutes
lancer tâche décompte avec un délai de 1 seconde et une fréquence de 1 secondes (java.util.Timer)

tâche décompte

Code pseudocode :

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

1
2
3
décompte = temps cible - temps actuel
si décompte<= 0 s'arrêter
afficher décompte

tâche principale

Code pseudocode :

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

1
2
3
 
arrêter tâche 2
...faire ce qu'on veut

**vertebre** · 17/11/2015, 15h49

Bonjour,

Merci pour cet algo il m'a été très utile pour tenter de comprendre ce dont j'avais besoin, et comment construire le pgr avec des timer.
J'ai essayé de comprendre leur utilisation et de pondre quelques trucs, en reprenant du code sur le web mais çe n'ai pas vraiment çà.

Pourrais tu m'éclairer sur ce que je n'arrive pas à concevoir et quel erreur de logique et d'incompréhension j'ai faite.

Par avance je tiens à te dire que je ne suis pas du tout balèze en développement(comme tu as pu le remarqué) ni même en compréhension ^^, ce qui parait souvent évident pour des développeurs ne l'ai pas forcément pour moi ; mais bon chacun fait avec son intelligence

voilà ce que j'ai fais:

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
package testtimer;
import java.util.Timer;
import java.util.TimerTask;
 
public class TimerPersoObjet {
 
 
	    public static void main(String[] args) {
 
	    	boolean isStarted = false;			   // état pour gérer le démarrage du timer
	        long temps = 7200000;                  // délai avant de répéter la tache : 7200000 = 7200 seconde soit 120mn
	        long startTime = 0;                    // délai avant la mise en route (0 démarre immédiatement)
	        Timer timer = new Timer();             // création du timer
 
 
	        if (isStarted) {	// Si la tâche a été ~cliqué ou activé (isStarted=true)
 
			     	// 1er timer pour effectuer la tâche du début
			        TimerTask tacheDebut = new TimerTask() {     // création et spécification de la tâche de début à effectuer 
 
			            @Override
			                public void run() {
			            	timer.scheduleAtFixedRate(tacheDebut, startTime,temps);  		// on lance le timer 
			            	System.out.println("tâche de début s'effectue"); // ici se qui doit être effectué
			                }
			        };
 
			        // 2 eme timer pour gérer l'affichage du décompte
			        TimerTask tacheDecompte = new TimerTask() {     // création et spécification de la tâche d'afficahge du décompte à effectuer        
			            @Override
			                public void run() {
			            	System.out.println("On affiche le décompte"); 	 // On affiche le décompte en millisecondes
			            	timer.schedule(tacheDecompte, 1, 1);					// tâche décompte avec un délai de 1 seconde et une fréquence de 1 secondes
			                }
			        };
 
			     // 2 eme timer pour gérer l'affichage du décompte
			        TimerTask tacheFin = new TimerTask() {     // création et spécification de la tâche d'afficahge du décompte à effectuer        
			            @Override
			                public void run() {
			            	timer.schedule(tacheFin, 7200); // On effectue la tache de fin après le délai spécifié
			            	System.out.println("On affiche le décompte"); 	 // On affiche le décompte en millisecondes
			                }
			        };
 
 
 
	        }
	        else {
	        		// On vérifie si la valeur de isStarted régulièrement
	        }
 
 
	        // Méthode qui gère l'affichage du décompte
 
 
        }
 
}

Bonne journée,

**joel.drigo** · 17/11/2015, 16h16

La tâche principale c'est sous-entendu la tâche qui te sert pour lancer les autres tâches (en général c'est le thread main, mais ça peut être un autre thread (graphique par exemple)) mais ce n'est pas une TimerTask.

Ensuite, la TimerTask ne doit pas être programmée (scheduled) dans sa propre méthode run() puisque celle-ci sert à coder ce qu'on fait quand la tâche se déclenche : or, si elle n'est pas programmée, elle ne se déclenchera pas, et donc ne sera pas programmée...

Voilà l'exemple de principe.

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
public class TimerPersoObjet {
  private final static long HOUR = 60 * 60 * 1000;
	private final static long MIN = 60 * 1000;
	private final static long SEC = 1000;
	    public static void main(String[] args) {
 
	    	// fiinal long startDelay = 2 * HOUR; //120 min
 
	    	final long startDelay = 20 * SEC; // 20 sec pour tester
 
	    	final TimerTask countingDownTask = new TimerTask() {
 
	    		private final static long HOUR = 60 * 60 * 1000;
	    		private final static long MIN = 60 * 1000;
	    		private final static long SEC = 1000;
 
	    		long targetTime;
 
    			final StringBuilder sb = new StringBuilder("X h XX m XX s".length());
 
	    		@Override
	    		public void run() {
 
                                // ce code s'exécute toutes les secondes... (voir scheduleAtFixedRate plusloin)
 
	    			if ( targetTime==0 ) {
                                        // la première fois ( il y aura un petit décalage dû au temps d'exécution du timer.schedule(mainTask), qu'on peut minimiser en faisant des classes non anonyme avec une communication entre les deux, mais ce temps d'exécution devrait être quand même négligeable
	    				targetTime = System.currentTimeMillis() + startDelay;
	    			}
	    			else {
	    				sb.setLength(0);
	    			}
	    			long remainingTime = targetTime - System.currentTimeMillis();
 
	    			final long hour = remainingTime/HOUR;
	    			boolean prev = false;
	    			if ( hour>0 ) {
	    				sb.append(hour);
	    				sb.append(" H ");
	    				remainingTime%=HOUR;
	    				prev = true;
	    			}
 
	    			final long min = remainingTime/MIN;
	    			if ( min>0  ) {
	    				sb.append(min);
	    				sb.append(" m ");
	    				remainingTime%=MIN;
	    				prev = true;
	    			}
	    			else if ( prev ) {
	    				sb.append("00 m ");
	    			}
 
	    			final long sec = remainingTime/SEC;
	    			if ( sec>0 ) {
	    				sb.append(sec);
	    				sb.append(" s");
	    			}
	    			else if ( prev ) {
	    				sb.append("00 s");
	    			}
 
	    			System.out.println(sb); // ici affichage en console pour l'exemple
 
	    		}
 
	    	};
 
	    	final TimerTask mainTask = new TimerTask() {
 
	    		@Override
	    		public void run() {
	    			countingDownTask.cancel(); // on annule la tâche de décompte lorsque la tâche démarre
	    			// on fait ce qu'on veut faire dans 120 min
	    			System.out.println("On lance le boulot...");
	    		}
 
	    		@Override
	    		public boolean cancel() {
	    			countingDownTask.cancel(); // si on annule la tâche principale, on annule aussi le décompte
	    			return super.cancel();
	    		}
 
	    	};
 
	    	final Timer timer = new Timer();
	    	timer.schedule(mainTask, startDelay);
	    	timer.scheduleAtFixedRate(countingDownTask, 1000, 1000);
 
        }
 
}

**vertebre** · 17/11/2015, 19h24

:o super ! c'est exactement ce que je voulais faire, mercii !

Donc j'ai essayé de comprendre l'ensemble de tous le code, de le commenter et ... du coup je vais avoir pas mal de questions...

Pourquoi déclarer les variables HOUR, MIN et SEC dans la class et dans la méthode main de la class ?
Le StringBuilder (de ce que j'ai lu sert à stocker des chaines de caractères mutables, donc qui peuvent se transformer) mais à quel moment l'affiche t on ? et si cette chaine est mutable pourquoi la déclarer final ?
Dans les 3 variables constantes long hour, long min et long sec (de la 1ère fonction run) je ne comprend pas très bien ce boolean prev. Ce que je comprend c'est qu'il est à true lorsqu'il reste un nombre d'un de ces 3 temps dans le temps restant.
D'autre chose que je n'ai pas pu bien saisir se verront dans les commentaires que j'ai pu mettre

Voilà ton maginifique code

où j'ai pu rajouter des commentaires :

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
package testtimer;
import java.util.Timer;
import java.util.TimerTask;
 
public class TimerPersoObjet {
 
    private final static long HOUR = 60 * 60 * 1000;
  	private final static long MIN = 60 * 1000;
  	private final static long SEC = 1000;
 
  	public static void main(String[] args) {
 
  	    	// final long startDelay = 2 * HOUR; //120 min
  	    	final long startDelay = 20 * SEC; 	// 20 sec pour tester
 
  	    	// Déclaration d'un timerTask pour mettre à jour l'affichage de toutes les secondes
  	    	final TimerTask countingDownTask = new TimerTask() {
 
  	    		private final static long HOUR = 60 * 60 * 1000; 	// Variable Hour (heure en milliseconde)
  	    		private final static long MIN = 60 * 1000;		 	// Variable Min (minute en milliseconde)
  	    		private final static long SEC = 1000;			 	// Variable Sec (seconde en milliseconde)
 
  	    		long targetTime;	// Variable targetTime pour stocker le delay du décompte
 
      			final StringBuilder sb = new StringBuilder("X h XX m XX s".length());	// Variable contenant un objet StringBuilder pour les chaines de caractère mutable (qui se transforme), destiné à ...
 
  	    		@Override
  	    		// Fonction qui exécute le pourquoi de la tâche
  	    		public void run() {
 
                // ce code s'exécute toutes les secondes... (voir scheduleAtFixedRate plus loin)
 
  	    			if ( targetTime==0 ) {
                     // la première fois (il y aura un petit décalage dû au temps d'exécution du timer.schedule(mainTask), qu'on peut minimiser en faisant des classes non anonyme 
  	    			 // avec une communication entre les deux, mais ce temps d'exécution devrait être quand même négligeable
  	    				targetTime = System.currentTimeMillis() + startDelay;	// Variable targetTime pour stocker le temps actuel + 120 minutes
  	    			}
  	    			else {
  	    				sb.setLength(0);					
  	    			}
 
  	    			long remainingTime = targetTime - System.currentTimeMillis(); 	// variable remainingTime qui stocke le temps restant
 
  	    			final long hour = remainingTime/HOUR;	// Variable qui stocke le nombre d'heures restantes contenues dans le nombre de millisecondes restantes
  	    			boolean prev = false;
  	    			if ( hour>0 ) {
  	    				sb.append(hour);					// On affecte le nombre d'heures restantes dans la variable StringBuilder
  	    				sb.append(" H ");					
  	    				remainingTime%=HOUR;
  	    				prev = true;
  	    			}
 
  	    			final long min = remainingTime/MIN;		// Variable qui stocke le nombre de minutes restantes contenues dans le nombre de millisecondes restantes
  	    			if ( min>0  ) {
  	    				sb.append(min);						// On affecte le nombre de minutes restantes dans la variable StringBuilder
  	    				sb.append(" m ");					
  	    				remainingTime%=MIN;
  	    				prev = true;
  	    			}
  	    			else if ( prev ) {
  	    				sb.append("00 m ");
  	    			}
 
  	    			final long sec = remainingTime/SEC;		// Variable qui stocke le nombre de secondes restantes contenues dans le nombre de millisecondes restantes
  	    			if ( sec>0 ) {
  	    				sb.append(sec);						// On affecte le nombre de secondes restantes dans la variable StringBuilder
  	    				sb.append(" s");
  	    			}
  	    			else if ( prev ) {
  	    				sb.append("00 s");
  	    			}
 
  	    			System.out.println(sb); 	// ici affichage en console pour l'exemple
 
  	    		}
  	    	};
 
  	    	final TimerTask mainTask = new TimerTask() {	
 
  	    		@Override
  	    		public void run() {
  	    			countingDownTask.cancel(); 		// on annule la tâche de décompte lorsque la tâche démarre
  	    			// on fait ce qu'on veut faire dans 120 min
  	    			System.out.println("On lance le boulot...");
  	    		}
 
  	    		@Override
  	    		public boolean cancel() { // Fonction qui annule la tâche principale
  	    			countingDownTask.cancel(); // si on annule la tâche principale, on annule aussi le décompte
  	    			return super.cancel();
  	    		}
 
  	    	};
 
  	    	final Timer timer = new Timer();	// On déclare un timer constant	timer
  	    	timer.schedule(mainTask, startDelay);	// on démarre la tâche principal, c'est à dire un décompte de startDelay
  	    	timer.scheduleAtFixedRate(countingDownTask, 1000, 1000);	// tâche décompte avec un délai de 1 seconde et une fréquence de 1 secondes
 
          }
  }

PS: quand on code çà comme tu l'as fait en très peu de temps, on a combien d'année d'expérience en développement ?

**joel.drigo** · 17/11/2015, 19h40

J'avais déclaré les constantes dans la TimerTask, au début, mais je les déplacées pour pouvoir les utiliser plus globalement. Tu peux donc les enlever de la TimerTask (j'ai oublié) :

Code :

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

1
2
3
4
5
 TimerTask countingDownTask = new TimerTask() {
 
/*  	    		private final static long HOUR = 60 * 60 * 1000; 	// Variable Hour (heure en milliseconde)
  	    		private final static long MIN = 60 * 1000;		 	// Variable Min (minute en milliseconde)
  	    		private final static long SEC = 1000;			 	// Variable Sec (seconde en milliseconde)*/

Pour l'expérience en développement, mmm :

j'ai commencé à écrire des programmes en 1984/1985 (code spaghetti )
j'ai eu mes premier cours en 1987 (ou j'ai commencé à apprendre la programmation structurée - la base)
j'ai commencé à bosser en 1995 (PowerBuilder)
et je fais du Java depuis 1999/2000

**vertebre** · 17/11/2015, 19h49

ok sympa pour cette petite info.

Concernant mes questions je ne vais plus t’embêter alors, tu m'as déjà énormément aider, je chercherai tout seul.

Je passe en résolu et te remercie encore une fois .

Bonne soirée,

Décompte horaire

avec Java

Discussions similaires

Partager

Partager