0Pricing
Java Academy · Aula

Aquecimento e iterações

Meça o desempenho em estado estável.

Aquecimento e iterações é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 3 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.

Aquecimento e iterações

O JMH mede o desempenho em estado estacionário: a velocidade que seu código alcança depois que a JVM o otimiza completamente. Para isso, ele executa primeiro iterações de aquecimento descartáveis e depois iterações reais de medição. Nesta lição, você aprenderá a ajustar ambas.

Por que aquecer

As primeiras invocações são interpretadas e lentas; depois que o JIT compila o método frequentemente executado, as chamadas ficam muito mais rápidas. Incluir a inicialização lenta nos números os inflaria. As iterações de aquecimento executam o código, mas seus tempos são descartados.

@Warmup

@Warmup controla a fase descartável: quantas iterações serão executadas e quanto tempo cada uma durará.

import java.util.concurrent.TimeUnit;
import org.openjdk.jmh.annotations.*;

public class Bench {
    @Benchmark
    @Warmup(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)
    public int work() {
        return 7 * 6;
    }
}

@Measurement

@Measurement controla a fase real, registrada. Mais iterações reduzem o intervalo de confiança, mas prolongam a execução.

import java.util.concurrent.TimeUnit;
import org.openjdk.jmh.annotations.*;

public class Bench {
    @Benchmark
    @Measurement(iterations = 10, time = 1, timeUnit = TimeUnit.SECONDS)
    public int work() {
        return 7 * 6;
    }
}

Iterações versus operações

Tenha cuidado com os termos. Uma iteração é um intervalo cronometrado (por exemplo, um segundo). Dentro de cada intervalo, o JMH chama o método de avaliação de desempenho tantas vezes quanto possível; cada chamada é uma operação. A pontuação é informada por operação.

Quantos aquecimentos são suficientes

Observe a saída de cada iteração. Quando iterações sucessivas de aquecimento deixam de variar, o JIT se estabilizou. Se as primeiras iterações de medição ainda variarem, adicione mais aquecimento. Cinco iterações de aquecimento e dez de medição são um ponto de partida comum.

As execuções separadas adicionam mais aquecimento

Cada execução separada usa uma JVM completamente nova, portanto cada uma repete todo o aquecimento. Executar várias delas tanto isola os perfis do JIT quanto fornece a variação entre JVMs, que é a medida mais honesta da estabilidade.

import org.openjdk.jmh.annotations.*;

@Fork(3)
@Warmup(iterations = 5)
@Measurement(iterations = 10)
public class Bench {
    @Benchmark
    public double sqrt() {
        return Math.sqrt(2.0);
    }
}

Demonstrando o efeito

Este laço simples de Java imprime os tempos de cada lote. É comum observar os primeiros lotes executando mais lentamente que os posteriores, à medida que o JIT compila o método — exatamente o efeito que o aquecimento descarta.

public class Main {
    static long busy(int n) {
        long s = 0;
        for (int i = 0; i < n; i++) s += (long) Math.sqrt(i);
        return s;
    }
    public static void main(String[] args) {
        for (int batch = 0; batch < 5; batch++) {
            long t = System.nanoTime();
            long r = busy(2_000_000);
            System.out.println("batch " + batch + ": "
                + (System.nanoTime() - t) / 1000 + " us, r=" + r);
        }
    }
}

Baseado em tempo versus baseado em contagem

Por padrão, as iterações são baseadas em tempo (executam durante N segundos). Você pode mudar para uma quantidade fixa de operações com batchSize e modos de execução única, mas o modo baseado em tempo é o padrão porque se adapta à velocidade da máquina.

Não ajuste em excesso

Execuções muito longas consomem tempo sem melhorar muito a precisão quando o estado estacionário já foi alcançado. Busque números estáveis e repetíveis entre as execuções separadas, em vez de maximizar a quantidade de iterações. A reprodutibilidade é mais importante que uma única cifra impressionante.

Lendo a estabilização

O JMH imprime a pontuação de cada iteração durante a execução. Uma avaliação de desempenho saudável mostra as iterações de aquecimento convergindo e as iterações de medição agrupadas firmemente em torno da pontuação final, com um erro +/- pequeno.

Verificação rápida

Teste sua compreensão sobre aquecimento e iterações.

Recapitulação

Você aprendeu a medir o desempenho em estado estacionário:

  • @Warmup executa iterações descartadas para que o JIT possa compilar.
  • @Measurement executa as iterações registradas; mais iterações reduzem o intervalo de erro.
  • Uma iteração é um intervalo cronometrado; cada chamada dentro dela é uma operação.
  • Várias execuções com @Fork repetem o aquecimento em JVMs novas e revelam a variação entre JVMs.
  • Busque pontuações reproduzíveis e estáveis, em vez de maximizar a duração da execução.

Perguntas Frequentes

A aula “Aquecimento e iterações” é grátis?

Sim — o texto completo de “Aquecimento e iterações” é 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 “Aquecimento e iterações”?

Meça o desempenho em estado estável. 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 3 de 4.

Quanto tempo leva a aula “Aquecimento e iterações”?

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

  1. Por que usar JMH
  2. Escrevendo um benchmark
  3. Aquecimento e iterações
  4. Evitando eliminação de código morto
← Voltar para Java Academy