Java Academy · Aula

Identificando gargalos

Meça antes de otimizar.

Identificando gargalos é 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.

Meça, não suponha

A primeira regra do trabalho de desempenho é: meça antes de otimizar.

A intuição sobre onde um programa Java passa o tempo geralmente está errada. O compilador JIT, o coletor de lixo e o armazenamento em cache tornam as suposições imprecisas. Crie um perfil, encontre o verdadeiro ponto crítico e corrija-o.

Definição de gargalo

Um gargalo é a parte do sistema que limita a vazão ou a latência geral.

Otimizar qualquer outra coisa não traz benefício visível. A Lei de Amdahl torna isso preciso: se 90% do tempo está em um método, acelerar os outros 10% nunca poderá proporcionar mais de 11% de melhoria.

Latência versus vazão

Decida o que você está otimizando:

Latência — quanto tempo uma solicitação leva.
Vazão — quantas solicitações são processadas por segundo.

Há uma troca entre elas. O processamento em lote melhora a vazão, mas pode aumentar a latência por solicitação. Conheça seu objetivo antes de ajustar o sistema.

Medição do tempo transcorrido

A medição mais rudimentar é verificar o tempo transcorrido ao redor de um bloco de código com System.nanoTime().

Isso é útil para uma verificação rápida de plausibilidade, mas inclui o aquecimento do JIT, pausas da coleta de lixo e o ruído do escalonamento do OS; portanto, desconfie de valores isolados.

public class Main {
    public static void main(String[] args) {
        long start = System.nanoTime();
        long sum = 0;
        for (int i = 0; i < 10_000_000; i++) sum += i;
        long elapsed = System.nanoTime() - start;
        System.out.println("Sum: " + sum);
        System.out.println("Elapsed ms: " + (elapsed / 1_000_000.0));
    }
}

Cuidado com o aquecimento do JIT

Java começa interpretando o código de bytes e, depois, o compilador JIT compila os métodos mais utilizados em código nativo.

Por isso, as primeiras execuções de um método são muito mais lentas do que as posteriores. Um laço de medição ingênuo mede principalmente o aquecimento. Avaliações de desempenho reais fazem o aquecimento primeiro e medem depois o estado estacionário — exatamente o que o JMH faz por você.

Limitado pela CPU versus limitado por IO

Classifique o gargalo:

Limitado pela CPU — as linhas estão ocupadas calculando; os núcleos estão saturados.
Limitado por IO — as linhas aguardam o disco, a rede ou o banco de dados.

As ferramentas de criação de perfis distinguem esses casos como tempo de execução na CPU versus tempo bloqueado ou em espera. A correção é completamente diferente: algoritmos mais rápidos versus mais simultaneidade ou menos viagens de ida e volta.

Amostragem versus instrumentação

Há duas estratégias de criação de perfis:

Amostragem — captura rastreamentos da pilha periodicamente. Baixo custo adicional e resultado estatístico.
Instrumentação — insere contadores em cada método. É exata, mas pesada e pode distorcer as medições.

Em produção, prefira a amostragem de baixo custo adicional, como a do Java Flight Recorder.

A memória como gargalo

Muitas vezes, o custo real está na alocação, não na computação. A criação excessiva de objetos provoca coletas de lixo frequentes, consumindo CPU e adicionando pausas.

Acompanhe a taxa de alocação e o tempo de coleta de lixo. Reduzir alocações em um laço crítico frequentemente traz mais resultado do que ajustar minuciosamente a aritmética.

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        // Allocation-heavy: a new String each iteration
        List<String> garbage = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            garbage.add("item-" + i);
        }
        System.out.println("Allocated " + garbage.size() + " strings");
        System.out.println("In a hot loop, this churn drives GC pressure");
    }
}

Encontre o topo da pilha

Uma ferramenta de criação de perfis por amostragem produz uma lista de métodos classificados pela frequência com que apareceram em uma pilha da CPU — o tempo próprio.

O método no topo é seu candidato. Mas confirme se ele está no caminho crítico: um método muito utilizado que é executado em um componente de registro em segundo plano pode não afetar a latência percebida pelo usuário.

Estabeleça uma linha de base

Antes de alterar qualquer coisa, registre uma medição de linha de base sob uma carga realista.

Depois de cada alteração, faça uma nova medição e compare. Sem uma linha de base, você não pode provar que uma otimização ajudou — e muitas “otimizações” pioram as coisas. Altere uma coisa por vez.

Analise sob carga realista

Um gargalo encontrado em um laptop ocioso pode não ser o que causa problemas em produção.

Use tamanhos de dados e níveis de concorrência representativos.
Reproduza a carga de trabalho que realmente importa para os usuários.

Microtestes sintéticos podem direcionar você para um método que é irrelevante em escala. Analise o desempenho onde o problema realmente está.

Verificação rápida

Por que medições isoladas e ingênuas com System.nanoTime() de um método Java costumam induzir ao erro?

Recapitulação

Encontrar gargalos de forma disciplinada:

Meça antes de otimizar; a intuição engana.
Escolha um objetivo: latência ou taxa de transferência.
Classifique como limitado pela CPU ou por IO; observe a coleta de lixo e a alocação.
Prefira perfiladores de amostragem com baixa sobrecarga.
Cuidado com o aquecimento da compilação em tempo de execução; estabeleça uma linha de base e altere uma coisa de cada vez.

Perguntas Frequentes

A aula “Identificando gargalos” é grátis?

Sim — o texto completo de “Identificando gargalos” é 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 “Identificando gargalos”?

Meça antes de otimizar. 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 “Identificando gargalos”?

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