Skriv ett benchmark
@Benchmark och körlägen.
Skriv ett benchmark är en gratis lektion i Java Academy på CoddyKit. Detta är lektion 2 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Java Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Java Academy innehåller totalt 4 lektioner.
Skriva ett benchmarktest
Ett JMH-benchmarktest är helt enkelt en metod med annoteringen @Benchmark i en vanlig klass. JMH:s annoteringsprocessor genererar ett harness runt den. I den här lektionen går vi igenom annoteringarna som definierar vad och hur Ni mäter.
Annoteringen @Benchmark
Markera en valfri publik metod med @Benchmark, så anropar JMH den upprepade gånger och mäter tiden för varje anrop. Metoden bör returnera resultatet, inte kasta bort det, så att JMH kan konsumera det.
En minimal benchmarkklass
Så här ser ett benchmarktest ut i stora drag. Importen är org.openjdk.jmh.annotations.*. Eftersom JMH inte finns på den här körmiljöns classpath är detta endast ett illustrativt exempel.
import org.openjdk.jmh.annotations.Benchmark;
public class StringBench {
@Benchmark
public String concat() {
return "foo" + System.nanoTime();
}
}Benchmarklägen
@BenchmarkMode bestämmer vad som rapporteras:
- Throughput — operationer per tidsenhet (högre är bättre).
- AverageTime — tid per operation (lägre är bättre).
- SampleTime — tidsfördelning (percentiler).
- SingleShotTime — ett anrop, lämpligt för kallstart.
import org.openjdk.jmh.annotations.*;
public class Bench {
@Benchmark
@BenchmarkMode(Mode.AverageTime)
public int work() {
return 2 + 2;
}
}Välja utdataenheter
@OutputTimeUnit anger tidsenheten i rapporten så att värdena blir lättlästa. För en snabb operation passar nanosekunder; för en långsam operation passar millisekunder.
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;
}
}Returnera resultat
Returnera alltid resultatet av arbetet. JMH matar automatiskt alla returnerade värden till en Blackhole, vilket förhindrar eliminering av död kod. Ett void-benchmarktest som beräknar något och sedan kastar bort resultatet är ett klassiskt misstag.
Standardvärden för annoteringar
Annoteringar kan placeras på metoden eller på hela klassen. Annoteringar på klassnivå gäller för varje @Benchmark i klassen, vilket håller konfigurationen DRY när Ni har flera relaterade benchmarktester.
Fork-körningar
@Fork(n) kör benchmarktestet i n nya JVM-processer. Fork-körningar isolerar varje körning från JIT-profiler som byggts upp av tidigare benchmarktester, vilket förbättrar reproducerbarheten. Standardvärdet är en fork-körning.
import org.openjdk.jmh.annotations.*;
@Fork(2)
public class Bench {
@Benchmark
public long now() {
return System.nanoTime();
}
}Starta Runner
Ni startar benchmarktester via en main som konfigurerar ett Options-objekt och en Runner, eller via den genererade körbara JAR-filen. Regexuttrycket i include(...) väljer vilka benchmarktester som ska köras.
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();
}
}Läsa utdata
JMH skriver ut en tabell med benchmarktestets namn, läge, antal samplingar, resultatet, resultatets felmarginal och enheter, till exempel: Bench.work avgt 25 3.142 +/- 0.011 ns/op. +/- är konfidensintervallet.
Håll benchmarktesterna fokuserade
Varje benchmarktest bör mäta en enda sak. Om förberedelser, I/O och operationen som testas blandas ihop blir resultatet otydligt. Flytta förberedelserna till metoder med @Setup (som behandlas tillsammans med state), så att endast den heta kodvägen mäts.
Snabbkontroll
Testa er förståelse av hur man skriver benchmarktester.
Sammanfattning
Ni har lärt er att skriva ett JMH-benchmarktest:
- Annotera en metod med @Benchmark och returnera resultatet.
- @BenchmarkMode väljer Throughput, AverageTime, SampleTime eller SingleShotTime.
- @OutputTimeUnit anger lättlästa enheter; @Fork isolerar körningar i nya JVM-processer.
- Starta med en Runner + Options eller den genererade JAR-filen.
- Håll varje benchmarktest fokuserat på en enda het kodväg.
Lär dig Java med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 104
- Lektioner
- 374
Vanliga frågor
Är lektionen ”Skriv ett benchmark” gratis?
Ja – hela texten till ”Skriv ett benchmark” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Java Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i Java Academy innehåller totalt 4 lektioner.
Vad lär jag mig i ”Skriv ett benchmark”?
@Benchmark och körlägen. Ni övar på Java Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig Java Academy?
Du behöver inga förkunskaper. Utbildningen i Java Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 2 av 4.
Hur lång tid tar lektionen ”Skriv ett benchmark”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här Java Academy-lektionen?
Ja. Varje Java Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- Varför JMH
- Skriv ett benchmark
- Uppvärmning och iterationer
- Undvik eliminering av död kod