Java Academy · Lezione

Scrivere un benchmark

@Benchmark e modalità

Scrivere un benchmark è una lezione Java Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Java Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Java Academy include 4 lezioni in totale.

Scrivere un benchmark

Un benchmark JMH è semplicemente un metodo annotato con @Benchmark all'interno di una classe ordinaria. Il processore di annotazioni di JMH genera l'harness che lo circonda. In questa lezione verranno illustrate le annotazioni che definiscono cosa e come misurare.

L'annotazione @Benchmark

Contrassegni qualsiasi metodo pubblico con @Benchmark: JMH lo invocherà ripetutamente, misurando ogni chiamata. Il valore restituito dal metodo dovrebbe essere effettivamente restituito, non scartato, affinché JMH possa utilizzarlo.

Una classe benchmark minimale

Questa è la struttura di un benchmark. L'import è org.openjdk.jmh.annotations.*. Poiché JMH non è presente nel classpath di questo runner, l'esempio ha solo valore illustrativo.

import org.openjdk.jmh.annotations.Benchmark;

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

Modalità di benchmark

@BenchmarkMode sceglie il valore riportato:

Throughput — operazioni per unità di tempo (maggiore è meglio).
AverageTime — tempo per operazione (minore è meglio).
SampleTime — distribuzione dei tempi (percentili).
SingleShotTime — una singola invocazione, utile per l'avvio a freddo.

import org.openjdk.jmh.annotations.*;

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

Scegliere le unità di output

@OutputTimeUnit imposta l'unità di tempo del report, così da rendere leggibili i valori. Per un'operazione rapida sono appropriati i nanosecondi; per una lenta, i millisecondi.

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;
    }
}

Restituire i risultati

Restituisca sempre il risultato dell'operazione. JMH inserisce automaticamente ogni valore restituito in un Blackhole, impedendo la dead-code elimination. Un benchmark void che calcola un risultato e lo scarta è un errore classico.

Valori predefiniti delle annotazioni

Le annotazioni possono essere applicate al metodo o all'intera classe. Le annotazioni a livello di classe si applicano a ogni @Benchmark della classe, evitando di ripetere la configurazione quando si hanno diversi benchmark correlati.

Fork

@Fork(n) esegue il benchmark in n processi JVM nuovi. Il fork isola ogni esecuzione dai profili JIT creati dai benchmark precedenti, migliorando la riproducibilità. Il valore predefinito è un fork.

import org.openjdk.jmh.annotations.*;

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

Avviare il runner

Avvii i benchmark tramite un main che configura un oggetto Options e un Runner, oppure tramite il JAR eseguibile generato. L'espressione regolare include(...) seleziona i benchmark da eseguire.

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();
    }
}

Leggere l'output

JMH stampa una tabella con il nome del benchmark, la modalità, il numero di campioni, il punteggio, l'errore del punteggio e le unità; per esempio: Bench.work avgt 25 3.142 +/- 0.011 ns/op. +/- indica l'intervallo di confidenza.

Mantenga i benchmark focalizzati

Ogni benchmark dovrebbe misurare una sola cosa. Mescolare la preparazione, l'I/O e l'operazione da testare rende il risultato poco chiaro. Sposti la preparazione nei metodi @Setup (trattati nella sezione sullo stato), così verrà misurato solo il percorso critico.

Verifica rapida

Verifichi la Sua comprensione della scrittura dei benchmark.

Riepilogo

Ha imparato a scrivere un benchmark JMH:

Annoti un metodo con @Benchmark e ne restituisca il risultato.
@BenchmarkMode seleziona Throughput, AverageTime, SampleTime o SingleShotTime.
@OutputTimeUnit imposta unità leggibili; @Fork isola le esecuzioni in JVM nuove.
Avvii il benchmark con un Runner e delle Options, oppure tramite il JAR generato.
Mantenga ogni benchmark focalizzato su un unico percorso critico.

Domande Frequenti

La lezione «Scrivere un benchmark» è gratuita?

Sì — il testo completo di «Scrivere un benchmark» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Java Academy, passa a CoddyKit PRO. Il corso Java Academy include 4 lezioni in totale.

Cosa imparerò in «Scrivere un benchmark»?

@Benchmark e modalità Eserciti Java Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Java Academy?

Non è richiesta alcuna esperienza precedente. Java Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «Scrivere un benchmark»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Java Academy?

Sì. Ogni lezione Java Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Java Academy