0Pricing
Java Academy · Lección

Escritura de un benchmark

@Benchmark y modos

Escritura de un benchmark es una lección gratuita de Java Academy en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Java Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Java Academy incluye 4 lecciones en total.

Escribir un benchmark

Un benchmark de JMH es simplemente un método anotado con @Benchmark dentro de una clase normal. El procesador de anotaciones de JMH genera el harness a su alrededor. En esta lección se explican las anotaciones que definen qué se mide y cómo se mide.

La anotación @Benchmark

Marque cualquier método público con @Benchmark y JMH lo invocará repetidamente, cronometrando cada llamada. El valor devuelto por el método debe devolverse (no descartarse) para que JMH pueda consumirlo.

Una clase de benchmark mínima

Esta es la estructura de un benchmark. La importación es org.openjdk.jmh.annotations.*. Como JMH no está en el classpath de este entorno de ejecución, el ejemplo es únicamente ilustrativo.

import org.openjdk.jmh.annotations.Benchmark;

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

Modos de benchmark

@BenchmarkMode determina qué se informa:

  • Throughput — operaciones por unidad de tiempo (cuanto mayor, mejor).
  • AverageTime — tiempo por operación (cuanto menor, mejor).
  • SampleTime — distribución de los tiempos (percentiles).
  • SingleShotTime — una invocación, útil para el arranque en frío.
import org.openjdk.jmh.annotations.*;

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

Elegir las unidades de salida

@OutputTimeUnit establece la unidad de tiempo del informe para que los valores sean fáciles de interpretar. Para una operación rápida, los nanosegundos son adecuados; para una lenta, los milisegundos.

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

Devolver resultados

Devuelva siempre el resultado del trabajo. JMH introduce automáticamente los valores devueltos en un Blackhole, lo que evita la eliminación de código muerto. Un benchmark void que calcula algo y lo descarta es un error clásico.

Valores predeterminados de las anotaciones

Las anotaciones pueden colocarse en el método o en toda la clase. Las anotaciones a nivel de clase se aplican a cada @Benchmark de esa clase, lo que evita repetir la configuración cuando tiene varios benchmarks relacionados.

Ejecuciones independientes

@Fork(n) ejecuta el benchmark en n procesos JVM nuevos. Las ejecuciones independientes aíslan cada ejecución de los perfiles del JIT creados por los benchmarks anteriores, lo que mejora la reproducibilidad. El valor predeterminado es una ejecución.

import org.openjdk.jmh.annotations.*;

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

Iniciar el Runner

Los benchmarks se inician mediante un main que configura un objeto Options y un Runner, o mediante el JAR ejecutable generado. La expresión regular de include(...) selecciona los benchmarks que se ejecutarán.

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

Leer la salida

JMH muestra una tabla con el nombre del benchmark, el modo, el número de muestras, la puntuación, el error de la puntuación y las unidades; por ejemplo: Bench.work avgt 25 3.142 +/- 0.011 ns/op. El +/- es el intervalo de confianza.

Mantener los benchmarks centrados

Cada benchmark debe medir una sola cosa. Mezclar la preparación, la E/S y la operación que se está probando enturbia el resultado. Traslade la preparación a métodos @Setup (que se explican junto con el estado) para cronometrar únicamente la ruta caliente.

Comprobación rápida

Compruebe su comprensión de cómo escribir benchmarks.

Repaso

Ha aprendido a escribir un benchmark de JMH:

  • Anote un método con @Benchmark y devuelva el resultado.
  • @BenchmarkMode selecciona Throughput, AverageTime, SampleTime o SingleShotTime.
  • @OutputTimeUnit establece unidades legibles; @Fork aísla las ejecuciones en JVM nuevas.
  • Inícielo con un Runner y Options, o con el JAR generado.
  • Mantenga cada benchmark centrado en una sola ruta caliente.

Preguntas frecuentes

¿La lección «Escritura de un benchmark» es gratis?

Sí — el texto completo de «Escritura de un benchmark» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Java Academy, actualiza a CoddyKit PRO. El curso de Java Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Escritura de un benchmark»?

@Benchmark y modos Practicas Java Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Java Academy?

No se requiere experiencia previa. Java Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «Escritura de un benchmark»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Java Academy?

Sí. Cada lección de Java Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Por qué usar JMH
  2. Escritura de un benchmark
  3. Calentamiento e iteraciones
  4. Cómo evitar la eliminación de código muerto
← Volver a Java Academy