JMH est un cadre pour écrire des microbenchacs Java précis qui peuvent éviter les écarts de mesure causés par l'optimisation de JVM. 1. Utilisez Maven ou Gradle pour ajouter des dépendances JMH-Core et JMH-Generator-AnnProcess et activer le traitement d'annotation. 2. écrivez des méthodes de test de référence et des paramètres de configuration annoté avec @BenchMark, @BenchMarkMode, @WarmUp, @Measurement, @Fork, etc. 3. Empêchez la valeur de retour de l'opération qui prend du temps d'être éliminé par optimisation JIT via return ou blackhole.consume (). 4. Utilisez @State (Scope.thread) pour définir la classe d'état et initialisez les données de test dans la méthode @SetUp pour éviter de contaminer la méthode de référence. 5. Exécutez le test via MVN Clean Installer et Java -Jar et analysez les résultats du temps, de l'erreur et des unités moyens. 6. L'utilisation de microbanchmarks uniquement lors de la comparaison des algorithmes, des structures de données ou des configurations JVM ne remplace pas les tests de charge à l'échelle du système. L'utilisation correcte de JMH peut répondre avec précision à la question de "ce qui est plus rapide à mettre en ?uvre" et tirer des conclusions fiables.

Lorsque vous mesurez les performances du code Java, l'utilisation du simple System.currentTimeMillis() ou System.nanoTime() peut conduire à des résultats trompeurs en raison d'optimisations JVM comme la compilation JIT, l'élimination du code mort et les effets d'échauffement. C'est là que le harnais de microbenchmarché Java (JMH) entre en jeu - un cadre robuste con?u spécifiquement pour l'écriture et l'exécution de microbennch-marques précises.

Qu'est-ce que JMH?

JMH est un projet open source développé dans le cadre de l'OpenJDK. Il aide les développeurs à écrire des repères fiables en gérant automatiquement les pièges communs. Il est largement utilisé dans les applications critiques, les bibliothèques et les cadres (comme JDK lui-même) pour comparer les petites unités de code dans des conditions contr?lées.

Vous n'utilisez pas seulement JMH - vous concevez des repères avec. Il garantit un échauffement approprié, empêche l'élimination du code, gère le filetage et fournit une analyse statistique des résultats.

Configuration de JMH dans votre projet

Le moyen le plus simple de commencer est d'utiliser Maven ou Gradle.

Avec maven:

Ajoutez ceci à votre pom.xml :

 <dépendance>
    <groupId> org.openjdk.jmh </pr?dID>
    <ArtefactId> JMH-core </letefactive>
    <version> 1.37 </ version>
</Dependance>
<dépendance>
    <groupId> org.openjdk.jmh </pr?dID>
    <ArtefactId> JMH-Generator-Annprocess </Retifactid>
    <version> 1.37 </ version>
    <ccope> fourni </ccope>
</Dependance>

Ensuite, activez le traitement d'annotation dans votre outil IDE ou Build afin que les méthodes @Benchmark soient traitées correctement.

Alternativement, utilisez le plugin JMH Maven pour générer un pot de référence autonome:

 archétype MVN: générer \
    -DinterActiveMode = false \
    -DarchetyPegroupId = org.openjdk.jmh \
    -DarchetyPearFactId = JMH-Java-Benchmark-ArcheType \
    -DgroupId = com.example \
    -DartifActid = JMH-Demo

Cela crée un projet avec tout ce qui est préconfiguré.

écrire votre premier benchmark

Voici un exemple simple comparant deux fa?ons de concaténer les cha?nes: StringBuilder vs String .

 @Benchmark
@BenchMarkMode (mode.AverageTime)
@OutputTimeUnit (timeUnit.nanoseconds)
@Fork (1)
@WarmUp (itérations = 3, temps = 1)
@Measurement (itérations = 5, temps = 1)
public String testStringBuilder () {
    StringBuilder sb = new StringBuilder ();
    SB.APPEND ("Hello");
    SB.APPEND ("Monde");
    return sb.toString ();
}

@Benchmark
@BenchMarkMode (mode.AverageTime)
@OutputTimeUnit (timeUnit.nanoseconds)
@Fork (1)
@WarmUp (itérations = 3, temps = 1)
@Measurement (itérations = 5, temps = 1)
Public String testStringConcat () {
    String S = "Hello";
    s = "monde";
    retour s;
}

Annotations clés expliquées:

• @Benchmark : marque la méthode à mesurer.
• @BenchmarkMode : définit la métrique à collecter. Mode.AverageTime signifie nanosecondes par opération.
• @OutputTimeUnit : définit l'unité d'heure pour les résultats.
• @Fork : Nombre de processus JVM distincts à exécuter. Aide à isoler les résultats.
• @Warmup : Combien d'itérations à exécuter avant la mesure réelle (permet à Jit optimiser).
• @Measurement : combien d'itérations à utiliser pour collecter des données.

Exécutez l'indice de référence via:

 MVN Clean Installation
Java -Jar Target / Benchmarks.jar

Pièges et meilleures pratiques communes

Même avec JMH, une utilisation incorrecte peut fausser les résultats. Voici des choses clés à regarder:

• évitez l'élimination du code mort : si le résultat n'est pas utilisé ou retourné, JVM peut optimiser le tout. Renvoyez toujours une valeur de votre méthode de référence, le cas échéant.

   @Benchmark
    String public MyBenchmark () {
        // fonctionne
        Résultat de retour; // important!
    }

• Utilisez Blackhole pour consommer des valeurs lorsque vous ne voulez pas les retourner:

   @Benchmark
    public void useblackhole (Blackhole BH) {
        STRING RESTURS = CHER-OPERATION ();
        bh.consume (résultat);
    }

• Ne mettez pas la logique de configuration à l'intérieur de la méthode de référence . Utilisez @Setup :

   @State (scope.thread)
    classe statique publique Mystate {
        Données de liste publique <string>;
  
        @Installation
        Public Void SetUp () {
            data = arrays.aslist ("a", "b", "c");
        }
    }
  
    @Benchmark
    public void processList (MyState State) {
        // Utilisez State.Data
    }

• Comprendre Scope dans @State :

  • Scope.Thread : chaque fil obtient sa propre instance.
  • Scope.Benchmark : partagé sur tous les threads (utilisez attentivement).
  • Scope.Group : pour les threads dans un groupe de threads.

• Contr?lez le parallélisme avec @Threads et @Fork pour simuler la concurrence du monde réel.

Interpréter les résultats

Exemple de sortie:

 Mode de référence CNT Score d'erreur Unités
MyBenchmark.TestStringBuilder Avgt 5 8,234 ± 0,198 ns / op
MyBenchMark.TestStringConcat Avgt 5 12.451 ± 0,302 NS / OP

Cela vous indique qu'en moyenne, StringBuilder était plus rapide que la concaténation des cordes dans ce test.

JMH rapporte également le débit ( Mode.Throughput ), les temps d'échantillonnage et génère même des graphiques de flamme s'il est configuré.

Quand devriez-vous utiliser JMH?

• Comparaison de deux algorithmes (par exemple, tri, hachage).
• évaluation des performances de la structure des données (par exemple, ArrayList vs LinkedList ).
• Tester l'impact des drapeaux JVM ou des paramètres GC.
• Valider les hypothèses de performance avant de fusionner les optimisations.

Mais n'oubliez pas: les microbenchères ne remplacent pas les tests de charge réel . Ils présentent un comportement isolé, et non des performances à l'échelle du système.

Fondamentalement, si vous essayez de répondre à "cette boucle est-elle plus rapide que celle-là?" ou ?Cette stratégie de cache réduit-elle l'allocation??, JMH est le bon outil - tant que vous l'utilisez correctement.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!