Java Academy · Leçon

Écrire une référence

@Benchmark et modes

Écrire une référence est une leçon Java Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Java Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Java Academy comprend 4 leçons au total.

Écrire une évaluation comparative

Une évaluation comparative JMH est simplement une méthode annotée avec @Benchmark à l’intérieur d’une classe ordinaire. Le processeur d’annotations de JMH génère l’infrastructure d’exécution autour de cette méthode. Cette leçon présente les annotations qui définissent ce que vous mesurez et la manière de le mesurer.

L’annotation @Benchmark

Marquez toute méthode publique avec @Benchmark et JMH l’appellera de manière répétée en chronométrant chaque appel. La valeur renvoyée par la méthode doit bien être retournée, et non supprimée, afin que JMH puisse la consommer.

Une classe d’évaluation comparative minimale

Voici la structure d’une évaluation comparative. L’importation est org.openjdk.jmh.annotations.*. Comme JMH ne figure pas dans le chemin de classes de cet environnement d’exécution, cet exemple est uniquement illustratif.

import org.openjdk.jmh.annotations.Benchmark;

public class StringBench {
    @Benchmark
    public String concat() {
        return "foo" + System.nanoTime();
    }
}

Modes d’évaluation comparative

@BenchmarkMode choisit ce qui est affiché :

Débit — opérations par unité de temps (plus élevé est préférable).
AverageTime — durée par opération (plus faible est préférable).
SampleTime — répartition des durées (percentiles).
SingleShotTime — un seul appel, adapté au démarrage à froid.

import org.openjdk.jmh.annotations.*;

public class Bench {
    @Benchmark
    @BenchmarkMode(Mode.AverageTime)
    public int work() {
        return 2 + 2;
    }
}

Choisir les unités de sortie

@OutputTimeUnit définit l’unité de temps utilisée dans le rapport afin que les nombres soient lisibles. Pour une opération rapide, les nanosecondes sont pertinentes ; pour une opération lente, les millisecondes.

import java.util.concurrent.TimeUnit;
import org.openjdk.jmh.annotations.*;

public class Bench {
    @Benchmark
    @BenchmarkMode(Mode.AverageTime)
    @OutputTimeUnit(TimeUnit.NANOSECONDS)
    public int work() {
        return 42;
    }
}

Renvoyer les résultats

Retournez toujours le résultat du travail effectué. JMH transmet automatiquement les valeurs renvoyées à un puits noir, ce qui empêche la suppression du code mort. Une évaluation comparative sans valeur de retour qui calcule puis supprime le résultat est une erreur classique.

Valeurs par défaut des annotations

Les annotations peuvent être placées sur la méthode ou sur toute la classe. Les annotations placées au niveau de la classe s’appliquent à chaque @Benchmark de cette classe, ce qui permet de conserver une configuration DRY lorsque vous avez plusieurs évaluations comparatives liées.

Exécution dans des processus distincts

@Fork(n) exécute l’évaluation comparative dans n processus JVM neufs. Cette séparation isole chaque exécution des profils du compilateur à la volée constitués par les évaluations comparatives précédentes, ce qui améliore la reproductibilité. La valeur par défaut est un processus distinct.

import org.openjdk.jmh.annotations.*;

@Fork(2)
public class Bench {
    @Benchmark
    public long now() {
        return System.nanoTime();
    }
}

Lancer l’exécuteur

Vous démarrez les évaluations comparatives via un main qui configure un objet d’options et un exécuteur, ou via le JAR exécutable généré. L’expression régulière include(...) sélectionne les évaluations comparatives à exécuter.

import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.options.*;

public class Launcher {
    public static void main(String[] args) throws Exception {
        Options opt = new OptionsBuilder()
            .include("Bench")
            .build();
        new Runner(opt).run();
    }
}

Lire la sortie

JMH affiche un tableau contenant le nom de l’évaluation comparative, le mode, le nombre d’échantillons, le score, l’erreur du score et les unités, par exemple : Bench.work avgt 25 3.142 +/- 0.011 ns/op. Le +/- représente l’intervalle de confiance.

Garder les évaluations comparatives ciblées

Chaque évaluation comparative doit mesurer une seule chose. Mélanger la préparation, les E/S et l’opération évaluée brouille le résultat. Déplacez la préparation dans des méthodes @Setup (présentées avec l’état) afin de ne chronométrer que le chemin d’exécution critique.

Vérification rapide

Vérifiez votre compréhension de l’écriture d’évaluations comparatives.

Récapitulatif

Vous avez appris à écrire une évaluation comparative JMH :

Annotez une méthode avec @Benchmark et retournez le résultat.
@BenchmarkMode choisit Débit, AverageTime, SampleTime ou SingleShotTime.
@OutputTimeUnit définit des unités lisibles ; @Fork isole les exécutions dans de nouvelles JVM.
Lancez-la avec un exécuteur et des options, ou avec le JAR généré.
Concentrez chaque évaluation comparative sur un seul chemin d’exécution critique.

Questions Fréquemment Posées

La leçon « Écrire une référence » est-elle gratuite ?

Oui — le texte complet de « Écrire une référence » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Java Academy, passe à CoddyKit PRO. Le cours Java Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Écrire une référence » ?

@Benchmark et modes Tu pratiques Java Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Java Academy ?

Aucune expérience préalable n'est requise. Java Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Écrire une référence » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Java Academy ?

Oui. Chaque leçon Java Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Java Academy