Java Academy · Aula

Escrevendo um benchmark

@Benchmark e modos.

Escrevendo um benchmark é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Java Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Java Academy inclui 4 aulas no total.

Escrevendo uma avaliação de desempenho

Uma avaliação de desempenho do JMH é apenas um método anotado com @Benchmark dentro de uma classe comum. O processador de anotações do JMH gera a estrutura ao redor dele. Nesta lição, você verá as anotações que definem o que e como medir.

A anotação @Benchmark

Marque qualquer método público com @Benchmark, e o JMH o invocará repetidamente, cronometrando cada chamada. O método deve devolver seu valor de retorno, em vez de descartá-lo, para que o JMH possa consumi-lo.

Uma classe mínima de avaliação

Veja a estrutura de uma avaliação de desempenho. A importação é org.openjdk.jmh.annotations.*. Como o JMH não está no caminho de classes deste executor, isto serve apenas como ilustração.

import org.openjdk.jmh.annotations.Benchmark;

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

Modos de avaliação

@BenchmarkMode escolhe o que será informado:

Vazão — operações por unidade de tempo (quanto maior, melhor).
AverageTime — tempo por operação (quanto menor, melhor).
SampleTime — distribuição dos tempos (percentis).
SingleShotTime — uma invocação, adequada para a inicialização a frio.

import org.openjdk.jmh.annotations.*;

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

Escolhendo as unidades de saída

@OutputTimeUnit define a unidade de tempo do relatório para que os números sejam legíveis. Para uma operação rápida, nanossegundos fazem sentido; para uma operação lenta, milissegundos.

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

Retornando resultados

Sempre devolva o resultado do trabalho. O JMH alimenta automaticamente os valores retornados em um buraco negro, impedindo a eliminação de código morto. Uma avaliação de desempenho void que calcula e descarta o resultado é um erro clássico.

Padrões das anotações

As anotações podem ficar no método ou na classe inteira. As anotações aplicadas à classe valem para cada @Benchmark nessa classe, mantendo a configuração DRY quando você tem várias avaliações de desempenho relacionadas.

Execuções separadas

@Fork(n) executa a avaliação de desempenho em n processos novos da JVM. A execução separada isola cada execução dos perfis do JIT acumulados por avaliações anteriores, melhorando a reprodutibilidade. O padrão é uma execução separada.

import org.openjdk.jmh.annotations.*;

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

Iniciando o executor

Você inicia as avaliações de desempenho por meio de um main que configura um objeto Options e um Runner, ou por meio do JAR executável gerado. A expressão regular include(...) seleciona quais avaliações serão executadas.

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

Lendo a saída

O JMH imprime uma tabela com o nome da avaliação, o modo, o número de amostras, a pontuação, o erro da pontuação e as unidades, por exemplo: Bench.work avgt 25 3.142 +/- 0.011 ns/op. O +/- é o intervalo de confiança.

Mantenha as avaliações focadas

Cada avaliação de desempenho deve medir uma única coisa. Misturar configuração, I/O e a operação em avaliação torna o resultado impreciso. Mova a preparação para métodos @Setup (abordados junto com o estado) para que apenas o trecho crítico seja cronometrado.

Verificação rápida

Teste sua compreensão sobre como escrever avaliações de desempenho.

Recapitulação

Você aprendeu a escrever uma avaliação de desempenho do JMH:

Anote um método com @Benchmark e devolva o resultado.
@BenchmarkMode escolhe Vazão, AverageTime, SampleTime ou SingleShotTime.
@OutputTimeUnit define unidades legíveis; @Fork isola as execuções em JVMs novas.
Inicie com um executor + opções ou com o JAR gerado.
Mantenha cada avaliação focada em um único trecho crítico.

Perguntas Frequentes

A aula “Escrevendo um benchmark” é grátis?

Sim — o texto completo de “Escrevendo um benchmark” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Java Academy, atualize para CoddyKit PRO. O curso de Java Academy inclui 4 aulas no total.

O que vou aprender em “Escrevendo um benchmark”?

@Benchmark e modos. Você pratica Java Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Java Academy?

Nenhuma experiência prévia é necessária. Java Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Escrevendo um benchmark”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Java Academy?

Sim. Cada aula de Java Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Java Academy