Por que usar JMH
Evite erros ingênuos em benchmarks.
Por que usar JMH é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 1 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.
Por que usar JMH
A estrutura de microavaliação de desempenho do Java (JMH) é a ferramenta padrão para medir o desempenho de pequenos trechos de código Java. Laços de medição escritos manualmente quase sempre produzem números incorretos, pois a JVM é um ambiente de execução sofisticado que faz otimizações.
O JMH existe para neutralizar essas armadilhas.
A avaliação de desempenho ingênua
Uma primeira tentativa comum envolve um laço em System.nanoTime(). Ela parece razoável, mas é profundamente falha para microavaliações de desempenho.
public class Main {
static int compute(int n) { return n * n + 7; }
public static void main(String[] args) {
long start = System.nanoTime();
int sink = 0;
for (int i = 0; i < 1_000_000; i++) sink = compute(i);
long elapsed = System.nanoTime() - start;
System.out.println("ns: " + elapsed + " sink=" + sink);
}
}Problema 1: aquecimento do JIT
A JVM começa no modo interpretado e só compila métodos frequentemente executados em código nativo após milhares de invocações. Uma avaliação de desempenho ingênua mede a fase interpretada, lenta, misturada à fase compilada, rápida, produzindo médias sem significado.
O JMH resolve isso com uma fase dedicada de aquecimento, que é descartada.
Problema 2: eliminação de código morto
Se um resultado calculado nunca for usado, o JIT poderá excluir completamente o cálculo. Sua avaliação de desempenho medirá então um laço vazio.
O JMH oferece o consumo do valor retornado e o Blackhole para impedir isso.
Problema 3: avaliação antecipada de constantes
Se as entradas forem constantes em tempo de compilação, o JIT calculará a resposta uma vez e a reutilizará. Abaixo, o compilador poderia substituir todo o laço por uma única constante.
O JMH usa objetos @State para manter as entradas opacas ao otimizador.
public class Main {
public static void main(String[] args) {
// 2 * 21 is constant; the JIT folds it to 42
int result = 2 * 21;
System.out.println(result);
}
}Problema 4: otimizações de laços
O JIT desenrola laços, move código invariável para fora deles e vetoriza operações. Um laço escrito manualmente mede essas otimizações, e não a operação que você pretendia testar.
O JMH substitui seu laço por contagens de iterações cuidadosamente controladas, gerenciadas por ele.
Problema 5: substituição na pilha
Um laço de longa duração em main pode ser compilado no meio da execução (substituição na pilha), produzindo características de desempenho diferentes das de um método compilado normalmente. Isso distorce os resultados de maneira imprevisível.
O que o JMH oferece
- Iterações de aquecimento separadas e descartadas.
- Várias iterações de medição com estatísticas.
- Execução em JVMs novas para evitar a poluição dos perfis.
- Buraco negro e consumo de resultados contra a eliminação de código morto.
- Objetos @State para impedir a avaliação antecipada de constantes.
Como executá-lo
O JMH é uma dependência separada (org.openjdk.jmh) e normalmente é iniciado por um processador de anotações junto a um build do Maven/Gradle que produz um JAR executável. Você não executa avaliações de desempenho a partir de um main simples, como faria com código comum.
As estatísticas são importantes
O JMH informa não apenas uma média, mas também o erro / intervalo de confiança entre as iterações e as execuções separadas. Um resultado como 42.0 +/- 1.3 ns/op informa tanto o valor central quanto o quanto ele variou — algo essencial para confiar em uma medição.
Quando recorrer ao JMH
Use o JMH ao comparar duas implementações de um trecho crítico, validar uma otimização ou medir operações na escala de nanossegundos a microssegundos. Para trabalhos mais grosseiros, medidos em segundos (I/O, rede), medir o tempo decorrido geralmente é suficiente.
Verificação rápida
Teste sua compreensão sobre a necessidade do JMH.
Recapitulação
Você aprendeu por que as microavaliações de desempenho precisam de uma estrutura:
- A JVM aquece: o código interpretado só se torna compilado após muitas chamadas.
- A eliminação de código morto e a avaliação antecipada de constantes podem excluir ou pré-calcular seu trabalho.
- Otimizações de laços e substituição na pilha distorcem laços escritos manualmente.
- O JMH adiciona aquecimento, iterações de medição, execuções separadas, buraco negro e estatísticas.
- Recorra a ele ao medir trechos críticos na escala de nanossegundos.
Perguntas Frequentes
A aula “Por que usar JMH” é grátis?
Sim — o texto completo de “Por que usar JMH” é 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 “Por que usar JMH”?
Evite erros ingênuos em benchmarks. 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 1 de 4.
Quanto tempo leva a aula “Por que usar JMH”?
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.