0Pricing
Scala for Backend Engineering & Functional Programming · Aula

Gerenciamento de memória e ajuste do GC

Aprofunde-se no gerenciamento de memória da JVM, na coleta de lixo e em técnicas para otimizar o uso de memória em Scala.

Gerenciamento de memória e ajuste do GC é uma aula grátis de Scala for Backend Engineering & Functional Programming no CoddyKit. Esta é a aula 2 de 3. 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 Scala for Backend Engineering & Functional Programming, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Scala for Backend Engineering & Functional Programming inclui 3 aulas no total.

Introdução à Memória da JVM e à Coleta de Lixo

Boas-vindas! Nesta lição, vamos entender como a Máquina Virtual Java (JVM) gerencia a memória, algo especialmente importante para aplicativos Scala.

  • Entender a memória ajuda você a escrever código eficiente e com bom desempenho.
  • Vamos explorar a coleta de lixo (GC), o gerenciador automático de memória da JVM.
  • O gerenciamento adequado da memória evita problemas comuns, como erros de falta de memória.

O Heap: Armazenamento de Objetos

O heap é a maior área de memória da JVM, onde ficam todos os objetos criados pelo seu aplicativo Scala. Isso inclui instâncias de classes, matrizes e a maioria das estruturas de dados.

O heap é compartilhado por todas as threads do seu aplicativo. Seu tamanho afeta diretamente quantos objetos o programa pode manter simultaneamente.

Pilha versus Heap: Principais Diferenças

Enquanto o heap armazena objetos, a pilha armazena variáveis locais, especialmente tipos primitivos e referências a objetos, além dos quadros de chamadas de métodos. Cada thread tem sua própria pilha.

  • Heap: Armazena objetos, é compartilhado e gerenciado pela coleta de lixo.
  • Pilha: Armazena chamadas de métodos e variáveis locais, é específica de cada thread e gerenciada automaticamente quando os métodos entram e saem.

Entender essa distinção é essencial para depurar problemas de memória.

Noções Básicas de Coleta de Lixo

A coleta de lixo (GC) é o processo automático da JVM que encontra e recupera a memória ocupada por objetos que não podem mais ser alcançados pelo aplicativo.

Em vez de liberar a memória manualmente, como em C++, Scala e Java dependem da coleta de lixo para evitar vazamentos de memória e simplificar o desenvolvimento. A ideia central é "marcar e varrer": marcar os objetos alcançáveis e depois remover os demais.

Coleta de Lixo Geracional Explicada

A maioria dos coletores de lixo modernos usa uma abordagem geracional, dividindo o heap em áreas com base na idade dos objetos:

  • Geração Jovem: Onde novos objetos são alocados. A maioria dos objetos é descartada ainda nessa geração.
  • Geração Antiga: Os objetos que sobrevivem a várias coletas na Geração Jovem são promovidos para cá.

Isso permite coletas mais frequentes e rápidas na Geração Jovem (coleta secundária) e coletas menos frequentes e mais lentas na Geração Antiga (coleta principal).

Coleções Scala e Memória

A ênfase de Scala na imutabilidade e na programação funcional frequentemente implica criar muitos objetos de curta duração, especialmente durante transformações de coleções.

A coleta de lixo é otimizada para esse cenário. Veja um exemplo de criação temporária de objetos durante o processamento de uma lista:

object Main {
  def main(args: Array[String]): Unit = {
    println("Creating and transforming a list...")
    val originalList = (1 to 100000).toList // ~100k objects
    val transformedList = originalList.map(x => x * 2).filter(_ % 3 == 0)
    println(s"Transformed list size: ${transformedList.size}")
    // originalList and intermediate lists from map are now eligible for GC
    println("Intermediate objects are efficiently managed by GC.")
  }
}

Cenários Comuns de Vazamento de Memória

Mesmo com a coleta de lixo, podem ocorrer vazamentos de memória quando objetos são mantidos vivos sem intenção por referências fortes. Entre os cenários comuns em Scala estão:

  • Cache de longa duração: Armazenar objetos indefinidamente em um mapa mutável global.
  • Fechamentos: Um fechamento, isto é, um literal de função, capturando um objeto grande que sobrevive ao escopo pretendido do fechamento.
  • Recursos não fechados: Não fechar corretamente identificadores de arquivos ou conexões de rede.

Referências Fracas para Cache

Para caches nos quais você quer que a coleta de lixo recupere a memória quando um objeto for referenciado apenas pelo cache, use java.lang.ref.WeakReference.

Uma WeakReference não impede que o objeto referenciado seja coletado. Se as únicas referências restantes a um objeto forem referências fracas, ele se tornará elegível para a coleta de lixo.

import java.lang.ref.WeakReference

object Main {
  def main(args: Array[String]): Unit = {
    var largeData: Array[Byte] = new Array[Byte](1024 * 1024) // 1MB
    val weakCacheEntry = new WeakReference(largeData)

    println(s"Data exists via weak ref: ${weakCacheEntry.get() != null}")

    largeData = null // Remove the strong reference

    System.gc() // Hint to the JVM to run GC
    Thread.sleep(100) // Give GC time to run

    println(s"Data collected (possibly): ${weakCacheEntry.get() == null}")
    println("WeakReference allows GC to clean up if no strong references remain.")
  }
}

Sinalizadores Básicos da JVM para Ajustar a Coleta de Lixo

Embora a coleta de lixo seja automática, você pode ajustar seu comportamento usando argumentos da JVM. Os principais sinalizadores incluem:

  • -Xmx: Define o tamanho máximo do heap Java, por exemplo, -Xmx4g para 4 gigabytes.
  • -Xms: Define o tamanho inicial do heap Java, por exemplo, -Xms512m para 512 megabytes.
  • -XX:+UseG1GC: Especifica o coletor Garbage-First (G1), uma opção moderna comum.

Ajustar esses sinalizadores pode afetar significativamente o desempenho e o uso de memória do aplicativo.

Verifique Seu Entendimento

Quais das afirmações a seguir sobre o gerenciamento de memória da JVM e a coleta de lixo são VERDADEIRAS?

Recapitulação: Memória e Coleta de Lixo

Excelente trabalho! Você explorou os fundamentos do gerenciamento de memória da JVM e da coleta de lixo:

  • O heap armazena objetos, enquanto a pilha armazena chamadas de métodos e variáveis locais.
  • A coleta de lixo recupera automaticamente a memória de objetos inacessíveis.
  • Entender a coleta de lixo geracional, com as gerações Jovem e Antiga, ajuda a otimizar o desempenho.
  • Fique atento aos vazamentos de memória e use ferramentas como WeakReference para necessidades específicas de cache.
  • Sinalizadores básicos da JVM, como -Xmx e -Xms, controlam o tamanho do heap.

A seguir, vamos conhecer ferramentas de criação de perfis para identificar gargalos!

Perguntas Frequentes

A aula “Gerenciamento de memória e ajuste do GC” é grátis?

Sim — o texto completo de “Gerenciamento de memória e ajuste do GC” é 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 Scala for Backend Engineering & Functional Programming, atualize para CoddyKit PRO. O curso de Scala for Backend Engineering & Functional Programming inclui 3 aulas no total.

O que vou aprender em “Gerenciamento de memória e ajuste do GC”?

Aprofunde-se no gerenciamento de memória da JVM, na coleta de lixo e em técnicas para otimizar o uso de memória em Scala. Você pratica Scala for Backend Engineering & Functional Programming 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 Scala for Backend Engineering & Functional Programming?

Nenhuma experiência prévia é necessária. Scala for Backend Engineering & Functional Programming 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 3.

Quanto tempo leva a aula “Gerenciamento de memória e ajuste do GC”?

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 Scala for Backend Engineering & Functional Programming?

Sim. Cada aula de Scala for Backend Engineering & Functional Programming 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. Analisando aplicações Scala
  2. Gerenciamento de memória e ajuste do GC
  3. Otimizando código concorrente
← Voltar para Scala for Backend Engineering & Functional Programming