Discussion :

[Nicolas_75]

Bonjour,

La classe ci-dessous possède une méthode permettant de renouveler 500 000 fois l'opération consistant à trouver sept nombres différents au hasard.

En appelant cette méthode quatre fois de suite, on s'aperçoit que la première exécution de la méthode semble jusqu'à 50 % plus coûteuse (en temps).

Essai n°1 : 187 ms
Essai n°2 : 125 ms
Essai n°3 : 110 ms
Essai n°4 : 109 ms

Savez-vous pourquoi ?

En vous remerciant par avance pour votre aide,
Cordialement,

Nicolas

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
import java.util.Random;
 
public class Test {
 
    private static final Random RANDOM = new Random();
 
    private static void findSevenDifferentNumbersAtRandom_N_times() {
        final int MAX = 49;
        for (int i = 0; i < 500000; i++) {
            int id1 = RANDOM.nextInt(MAX + 1);
            int id2 = id1;
            while (id2 == id1) {
                id2 = RANDOM.nextInt(MAX + 1);
            }
 
            int id3 = id2;
            while ((id3 == id2) || (id3 == id1)) {
                id3 = RANDOM.nextInt(MAX + 1);
            }
 
            int id4 = id3;
            while ((id4 == id3) || (id4 == id2) || (id4 == id1)) {
                id4 = RANDOM.nextInt(MAX + 1);
            }
 
            int id5 = id4;
            while ((id5 == id4) || (id5 == id3) || (id5 == id2) || (id5 == id1)) {
                id5 = RANDOM.nextInt(MAX + 1);
            }
 
            int id6 = id5;
            while ((id6 == id5) || (id6 == id4) || (id6 == id3) || (id6 == id2) || (id6 == id1)) {
                id6 = RANDOM.nextInt(MAX + 1);
            }
 
            int id7 = id6;
            while ((id7 == id6) || (id7 == id5) || (id7 == id4) || (id7 == id3) || (id7 == id2) || (id7 == id1)) {
                id7 = RANDOM.nextInt(MAX + 1);
            }
        }
    }
 
    public static void main(String[] args) {
        long time0, durationInMilliseconds;
        for (int i = 1; i <= 4; i++) {
            time0 = System.currentTimeMillis();
            findSevenDifferentNumbersAtRandom_N_times();
            durationInMilliseconds = System.currentTimeMillis() - time0;
            System.out.println("Essai n°" + i + " : " + durationInMilliseconds + " ms");
        }
    }
}

[adiGuba]

Salut,



Ce comportement vient du compilateur "HotSpot" !
En effet le bytecode peut être interprété/recompilé à la volée selon les cas, afin d'offrir les meilleures performances.

"HotSpot" signifie "point chaud". C'est à dire que le compilateur va recensé les parties de code qui sont exécutés le plus souvent pour les recompiler en natif avec les meilleures optimisations.

Mais cette compilation n'est pas systématique car dans bien des cas ce serait inutile et contre-performant.


Tu peux vérifier cela avec l'option -XX:+PrintCompilation de la JVM de Sun.
Enfin, même si ce n'est pas ton cas ici, le passage du GC peut également entrainer ce genre de résultat faussé. On peut le surveiller avec -XX:+PrintGC


a++

[LGnord]

Ce comportement est plus général. Lors de ton deuxième appel, il est possible que certaines valeurs soient encore dans le cache. Elle n'y était pas lors du premier.

Il existe d'autres contraintes techniques qui font que le premier appel est toujours plus long que les autres.

Serais-tu un joueur de loto?

Car 7 nombres différents compris entre 1 et 49 correspond parfaitement à la règle de ce jeu.