0Pricing
Java Academy · Aula

Algoritmos de GC: Serial, G1, ZGC e Shenandoah

Compare as características das pausas do GC e os compromissos de desempenho entre coletores modernos da JVM.

Algoritmos de GC: Serial, G1, ZGC e Shenandoah é 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.

Escolha de um algoritmo de coleta de lixo

A JVM inclui vários algoritmos de coleta de lixo, cada um otimizado para diferentes cargas de trabalho. A escolha do algoritmo adequado depende do tamanho da memória dinâmica, dos requisitos de latência e das metas de processamento.

// Enable GC algorithms:
// -XX:+UseSerialGC
// -XX:+UseParallelGC
// -XX:+UseG1GC       (default since Java 9)
// -XX:+UseZGC        (Java 15+ production)
// -XX:+UseShenandoahGC (Red Hat / OpenJDK builds)

Coleta de lixo serial

A coleta de lixo serial usa uma única linha de execução para a coleta. Todas as linhas de execução da aplicação param durante a coleta, em uma "parada total da aplicação". É adequada apenas para memórias dinâmicas pequenas ou ambientes com uma única CPU, como sistemas incorporados.

// Use:
// java -XX:+UseSerialGC -Xmx256m MyApp
// Pauses: long (proportional to heap size)
// Throughput: low
// Best for: CLI tools, small heaps < 100 MB

Coleta de lixo paralela (coletor de processamento)

A coleta de lixo paralela usa várias linhas de execução para coletas menores e principais. As pausas de parada total da aplicação são mais curtas que as da coleta serial, mas ainda são significativas. É ideal para processamento em lote, quando o processamento importa mais que a latência.

// Use:
// java -XX:+UseParallelGC -XX:ParallelGCThreads=8 MyApp
// Pauses: moderate
// Throughput: high
// Best for: batch jobs, number crunching

Coleta de lixo G1 (primeiro o lixo)

O G1 divide a memória dinâmica em regiões de tamanho igual, de aproximadamente 2 KB a 32 MB. Ele coleta primeiro as regiões com mais lixo, atendendo a uma meta de pausa configurável. É o padrão desde o Java 9.

// Use:
// java -XX:+UseG1GC -XX:MaxGCPauseMillis=200 MyApp
// Pauses: bounded by target (but not guaranteed)
// Throughput: good
// Best for: large heaps (4 GB+), mixed workloads

Tipos de região do G1

As regiões do G1 são atribuídas dinamicamente como Éden, sobrevivente, antiga ou gigantesca, para objetos grandes com mais de 50% do tamanho da região. Essa flexibilidade permite a coleta incremental.

ZGC (coletor de lixo Z)

ZGC realiza a maior parte do trabalho simultaneamente à aplicação. Os tempos de pausa normalmente ficam abaixo de 1 ms, independentemente do tamanho da memória dinâmica. Está pronto para produção desde o Java 15.

// Use:
// java -XX:+UseZGC -Xmx16g MyApp
// Pauses: < 1 ms (usually)
// Throughput: slightly lower than G1 (concurrent work has CPU cost)
// Best for: large heaps, low-latency services (APIs, trading)

Coleta de lixo Shenandoah

Shenandoah, da Red Hat, também alcança pausas inferiores a um milissegundo por meio de compactação simultânea. Está disponível em compilações do OpenJDK. Tem objetivos muito semelhantes aos do ZGC, mas usa algoritmos internos diferentes.

// Use:
// java -XX:+UseShenandoahGC MyApp
// Available in: Red Hat builds, some AdoptOpenJDK distributions
// Pauses: sub-millisecond
// Best for: latency-sensitive workloads

ZGC geracional (Java 21+)

O Java 21 introduziu o ZGC geracional, combinando a abordagem de pausas reduzidas do ZGC com a coleta geracional, reduzindo a sobrecarga da CPU e mantendo as pausas mínimas.

// Enable in Java 21+:
// java -XX:+UseZGC -XX:+ZGenerational -Xmx8g MyApp

Compromisso entre tempo de pausa e processamento

Nenhum algoritmo de coleta de lixo é o melhor em tudo. A coleta paralela maximiza o processamento. O G1 equilibra processamento e latência. ZGC e Shenandoah minimizam as pausas com um pequeno custo de processamento.

Ativação do registro de coleta de lixo

Registre eventos de coleta de lixo com -Xlog:gc*:file=gc.log:time,uptime,level. Analise os registros com ferramentas como GCViewer ou GCEasy para encontrar pausas longas e picos de alocação.

// JVM flags:
// -Xlog:gc*:file=gc.log:time,uptime,level,tags
// Inspect logs:
// cat gc.log | grep "Pause"

Monitoramento da coleta de lixo com métricas da JVM

Use ManagementFactory.getGarbageCollectorMXBeans() para ler programaticamente a contagem e o tempo da coleta de lixo ou exportá-los para o Prometheus por meio do Micrometer em aplicações Spring Boot.

ManagementFactory.getGarbageCollectorMXBeans().forEach(gc ->
    System.out.printf("%s: %d collections, %d ms%n",
        gc.getName(), gc.getCollectionCount(), gc.getCollectionTime()));

Verificação rápida

Qual algoritmo de coleta de lixo busca tempos de pausa inferiores a um milissegundo em produção?

Recapitulação

Coleta serial para memórias dinâmicas muito pequenas, coleta paralela para processamento em lote, G1 para cargas equilibradas, como padrão, e ZGC ou Shenandoah para latência extremamente baixa. Ative o registro da coleta de lixo em produção para detectar problemas com antecedência.

Perguntas Frequentes

A aula “Algoritmos de GC: Serial, G1, ZGC e Shenandoah” é grátis?

Sim — o texto completo de “Algoritmos de GC: Serial, G1, ZGC e Shenandoah” é 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 “Algoritmos de GC: Serial, G1, ZGC e Shenandoah”?

Compare as características das pausas do GC e os compromissos de desempenho entre coletores modernos da JVM. 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 “Algoritmos de GC: Serial, G1, ZGC e Shenandoah”?

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. Regiões do Heap da JVM e Ciclo de Vida dos Objetos
  2. Algoritmos de GC: Serial, G1, ZGC e Shenandoah
  3. Detecção e Correção de Vazamentos de Memória
  4. Opções de Ajuste do GC e Criação de Perfis com JVisualVM
← Voltar para Java Academy