a pb sans solution

**elalia** · 08/08/2006, 01h25

bonjour,
j'ai un pb trés simple mais me donne des résultats illogique , j'ai besoin une personne qui me dit pourquoi le tempsm dans ce code me donne des résulats nulls et des fois négatifs:
le code est le suivants:
try {int nbr=5;
do{
t1=System.currentTimeMillis();//System.out.println("t1:"+t1);
for ( int i=0; i<nbr;i++)
sleep(3000);

t2=System.currentTimeMillis();System.out.println("t2:"+t2);

temps=t2-t1-3000*nbr;
tempsm=temps/nbr;

System.out.println("load="+tempsm);

}while ( true);}catch(InterruptedException e) {};
j'attends votre réponses.
@+

**dazz_x** · 08/08/2006, 08h57

et bien des résultats nuls (ou très proche de 0) je trouverais ça plutôt normal parce que t2-t1 est égal au temps d'execution de nbr boucles de 3000ms d'attente et si par résultats "négatifs" tu entends des résultats du genre : -1.1236548943416436e-15, et bien bienvenue dans le monde du calcul flottant, parce qu'effectivement si les résultats sont trop proches de 0, il peut y avoir ce genre de comportement. Mais bon, 10e-15, c'est quand même très proche de 0.

Si tout ce que je dis est complètement à côté de la plaque, merci de bien vouloir envoyer les lettres d'insultes sous pli discret.

Salutations

**hydraland** · 08/08/2006, 09h07

Salut,

Je rajouterai que

Code :

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

System.currentTimeMillis()

est une méthode dépendante de la plate-forme et donc elle n'est pas forcément précise à la milliseconde près. Sous certain OSla précision peut être de l'ordre de la dizaine de millisecondes(C'est écrit dans la javadoc). D'ou les résultats que tu rencontres.

A+

**sinok** · 08/08/2006, 09h40

Avec ta multiplication, ne se pourrait il pas que tu explose la limite des long (ou int) car au delà d'une certaines valeur tu passe en négatif...

**elalia** · 08/08/2006, 10h19

dazz_xx: ce code calcule le moyen de temps d'attente d'un thread dans la file d'attente des processus pret dans la JVM,alors ce thread fait un sommeil puis revient à la file d'attente et attend un temp pour faire un autre sommeil, le moyen de ce temps c'est le temps d'attente que je cherchea cet effet t2.t1<> nbr*(temps de sommeil).
t1 et t2 sont de type long .

hydraland : je travaille sous windows et System.currentTimeMillis() en miliseconde.
sinok : n ya pas d'explmosion car lorsque j'affiche 3000*nbr il me donne des bons résultats mais parfois sont supèrieur à t2-t1.
et merci pour enrichir cette discussion.

**hydraland** · 08/08/2006, 10h52

Elalia,

Dans ton code t2 - t1 = nbr*3000 + temps mise à jour du for.
Donc la valeur de temps est toujours proche de zéro, puisque le temps de mise à jour du for est négligeable.
Comme je t'ai indiqué la méthode System.currentTimeMillis() n'a pas forcément une précision de l'ordre
de la milliseconde (même sous windows) ce qui veut dire que si on considère que ta boucle for prend T millisecondes alors
t2-t1 = T +/- (2*précision de la méthode System.currentTimeMillis()).

Sinon peux tu être plus clair sur ton besoin (en bon français s'il te plait

), car je n'ai pas compris ce que tu voulais faire.

A+

**adiGuba** · 08/08/2006, 11h03

Salut,

Envoyé par hydraland

Comme je t'ai indiqué la méthode System.currentTimeMillis() n'a pas forcément une précision de l'ordre
de la milliseconde (même sous windows)

En effet : sous Windows la précision est généralement de l'ordre de 16 ms environ...

Envoyé par hydraland

Sinon peux tu être plus clair sur ton besoin (en bon français s'il te plait

), car je n'ai pas compris ce que tu voulais faire.

+1 : je n'ai pas vraiment compris l'intérêt de tout cela...

a++

PS : et penses aux balises [code] pour la prochaine fois

**elalia** · 08/08/2006, 11h16

hydraland :je ne suis pas fransaise, mais j'essaie comme meme d'expliquer mon pb en français.

ce que tu n'as pas fait attention,c que lorsque le thread fait un sleep il libère le processeur aux autres threads ( soit de JVM ou de systeme d'exploitation ou des autres pgms ), et quand il termine sa pèriode de sommeil il attend son tour pour aquérir le processeur,c.à.d t2-t1 n'égale pas forcément au tempsde sommeil*nbre d'itérations.maist2-t1=(tempsde sommeil+temps d'attente)*nbre d'itérations.
j'espere que tu as compris la philosophie de cet algo et mon français aussi

@+

**adiGuba** · 08/08/2006, 11h26

elalia : Je pense que le manque de précision de currentTimeMillis() est à l'origine de cette erreur. Je ne pense pas que tu puisses y faire quelque chose...

a++

**elalia** · 08/08/2006, 11h38

MR Modérateur
mais j'ai pas compris ce que veut dire une précision de 16MS peut tu me diriger vers un lien pour mieux comprendre le pb de précision , peut etre je trouve un moyen d'ajustement.et merci pour votre contribution.

**hydraland** · 08/08/2006, 11h38

elalia,
Je comprend mieux

. Dans ce cas, si tu peux passer a Java 5, utilise la méthode nanoTime() qui est plus précise. Par contre
ton temps d'attente contiendra toujours le temps de mise à jour du for.

A+

**elalia** · 08/08/2006, 11h50

neuromencien
il ya 1 seule instruction dans la boucle for : sleep(3000);
et quand il sort de la boucle il calcule le temps d'attente : temps
merci comme meme.

**adiGuba** · 08/08/2006, 11h53

Envoyé par elalia

mais j'ai pas compris ce que veut dire une précision de 16MS peut tu me diriger vers un lien pour mieux comprendre le pb de précision

Cela signifie juste que la valzeur retourné par currentTimeMillis() est mises à jours environ toutes les 16ms seulement... Donc pendant 16ms il te reverra la même valeur.

Ce bout de code le montre très bien :

Code :

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

1
2
3
        for (int i=0; i<50000; i++) {
            System.out.println( System.currentTimeMillis() );
        }

a++

**neuromencien** · 08/08/2006, 11h56

Envoyé par elalia

neuromencien
il ya 1 seule instruction dans la boucle for : sleep(3000);
et quand il sort de la boucle il calcule le temps d'attente : temps
merci comme meme.

Lol

Oui je m'en suis apercu. J'en ai profité pour effacer mes bêtises mais pas assez vite

**XSeb74** · 08/08/2006, 12h00

j'ai un message ici je ne sait pas pourquoi !

**XSeb74** · 08/08/2006, 12h27

pourquoi un temps si long ?
pourquoi si peu de boucle ?
à quoi te sert ton while true à la fin ?

j'ai un peu modifié le résultat mais j'obtient ça :
temps=2703 pour 1000 boucles de 50ms =>2

**elalia** · 08/08/2006, 13h25

temps est long c logique puisque timemillis me donne une valeur de type long.
while et true : pour calculer le temps moyen d'une manière continue .
nombre d'itérations et le temps de sommeil :sont des paramétres q'on peut les changer .
@+

**elalia** · 08/08/2006, 13h32

Modérateur : est ce que je peux mettre
t1=System.currentTimeMillis() *16;
t2= t1=System.currentTimeMillis()*16;
je m'excuse je te casse la tete un peu.

**XSeb74** · 08/08/2006, 14h00

- la question est pourquoi 3000 ms plutot que 100 ?

- ton while true, tu rentrera dedans seulement quand tu sortira de ta boucle for, tu t'arrête jamais ?

- ça sert à quoi tout ça au juste ?

à première vue ça donne des fluctuations assez important :

temps=94 pour 100 boucles de 50ms =>0
temps=109 pour 100 boucles de 50ms =>1
temps=234 pour 100 boucles de 50ms =>2
temps=94 pour 100 boucles de 50ms =>0
temps=219 pour 100 boucles de 50ms =>2
temps=172 pour 100 boucles de 50ms =>1
temps=109 pour 100 boucles de 50ms =>1
temps=110 pour 100 boucles de 50ms =>1
temps=109 pour 100 boucles de 50ms =>1

**elalia** · 08/08/2006, 16h03

XSEB74
temps de sommeil=3000ms ---> le temps de sommeil doit etre +> au temps allouer par le SE à la JVM pour assuerer que le thread attend un certain temps pour aqérir le processeur.
boucle infinie --------> pour calculer le temps d'attente de la station d'une maniere continue sans arret
Et tout ça pour l'intégrer dans un autre pgm.
@+

a pb sans solution

Java

Discussions similaires

Partager

Partager