0Pricing
Scala for Backend Engineering & Functional Programming · Leçon

Gestion de la mémoire et optimisation du GC

Explorez en profondeur la gestion de la mémoire de la JVM, le ramasse-miettes et les techniques d’optimisation de l’utilisation de la mémoire en Scala.

Gestion de la mémoire et optimisation du GC est une leçon Scala for Backend Engineering & Functional Programming gratuite sur CoddyKit. Ceci est la leçon 2 sur 3. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Scala for Backend Engineering & Functional Programming, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Scala for Backend Engineering & Functional Programming comprend 3 leçons au total.

Introduction à la mémoire de la JVM et à la collecte des déchets

Bienvenue ! Dans cette leçon, nous allons étudier la manière dont la machine virtuelle Java (JVM) gère la mémoire, un aspect particulièrement important pour les applications Scala.

  • Comprendre la mémoire vous aide à écrire du code efficace et performant.
  • Nous allons découvrir la collecte des déchets, le gestionnaire automatique de mémoire de la JVM.
  • Une bonne gestion de la mémoire évite des problèmes courants comme les erreurs de mémoire insuffisante.

Le tas : stockage des objets

Le tas est la plus grande zone mémoire de la JVM. C'est là que résident tous les objets créés par votre application Scala, notamment les instances de classes, les tableaux et la plupart des structures de données.

Le tas est partagé entre tous les threads de votre application. Sa taille détermine directement le nombre d'objets que votre programme peut conserver simultanément.

Pile ou tas : principales différences

Alors que le tas contient les objets, la pile stocke les variables locales, en particulier les types primitifs et les références d'objets, ainsi que les cadres d'appel des méthodes. Chaque thread possède sa propre pile.

  • Tas : stocke les objets, est partagé et est géré par la collecte des déchets.
  • Pile : stocke les appels de méthodes et les variables locales, est propre à chaque thread et est gérée automatiquement lors de l'entrée et de la sortie des méthodes.

Comprendre cette distinction est essentiel pour résoudre les problèmes de mémoire.

Principes de la collecte des déchets

La collecte des déchets est le processus automatique de la JVM qui consiste à rechercher et à récupérer la mémoire occupée par les objets qui ne sont plus « accessibles » par l'application.

Au lieu de libérer manuellement la mémoire, comme en C++, Scala, tout comme Java, s'appuie sur la collecte des déchets pour éviter les fuites de mémoire et simplifier le développement. L'idée centrale est « marquer et balayer » : marquer les objets accessibles, puis supprimer les autres.

La collecte générationnelle expliquée

La plupart des collecteurs modernes utilisent une approche générationnelle, qui divise le tas en zones selon l'âge des objets :

  • Jeune génération : zone où les nouveaux objets sont alloués. La plupart des objets y disparaissent rapidement.
  • Ancienne génération : les objets qui survivent à plusieurs collectes dans la jeune génération y sont promus.

Cela permet d'effectuer des collectes plus fréquentes et plus rapides dans la jeune génération (collectes mineures), et des collectes moins fréquentes mais plus lentes dans l'ancienne génération (collectes majeures).

Collections Scala et mémoire

L'importance accordée par Scala à l'immuabilité et à la programmation fonctionnelle implique souvent la création de nombreux objets à courte durée de vie, notamment lors des transformations de collections.

La collecte des déchets est optimisée pour ce cas. Voyons un exemple de création temporaire d'objets lors du traitement d'une liste :

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.")
  }
}

Scénarios courants de fuite de mémoire

Même avec la collecte des déchets, des fuites de mémoire peuvent se produire lorsque des références fortes maintiennent involontairement des objets en vie. Parmi les scénarios courants en Scala :

  • Antémémoires à longue durée de vie : stocker indéfiniment des objets dans une carte mutable globale.
  • Fermetures : une fermeture, c'est-à-dire une fonction littérale, qui capture un objet volumineux dont la durée de vie dépasse la portée prévue de la fermeture.
  • Ressources non fermées : ne pas fermer correctement les descripteurs de fichiers ou les connexions réseau.

Références faibles pour la mise en cache

Pour les antémémoires où vous souhaitez que la collecte des déchets récupère la mémoire lorsqu'un objet n'est référencé que par l'antémémoire, utilisez java.lang.ref.WeakReference.

Une WeakReference n'empêche pas son objet référencé d'être récupéré par la collecte des déchets. Si les seules références restantes vers un objet sont des références faibles, l'objet devient éligible à la collecte.

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.")
  }
}

Options JVM de base pour régler la collecte

Bien que la collecte des déchets soit automatique, vous pouvez régler son comportement à l'aide d'arguments de la JVM. Les principales options sont les suivantes :

  • -Xmx : définit la taille maximale du tas Java, par exemple -Xmx4g pour 4 gigaoctets.
  • -Xms : définit la taille initiale du tas Java, par exemple -Xms512m pour 512 mégaoctets.
  • -XX:+UseG1GC : spécifie le collecteur Garbage-First (G1), un choix moderne courant.

Le réglage de ces options peut avoir un impact important sur les performances et l'utilisation de la mémoire de l'application.

Vérifiez votre compréhension

Lesquelles des affirmations suivantes concernant la gestion de la mémoire de la JVM et la collecte des déchets sont TRUE ?

Bilan : mémoire et collecte des déchets

Excellent travail ! Vous avez étudié les bases de la gestion de la mémoire de la JVM et de la collecte des déchets :

  • Le tas contient les objets, tandis que la pile contient les appels de méthodes et les variables locales.
  • La collecte des déchets récupère automatiquement la mémoire des objets inaccessibles.
  • Comprendre la collecte générationnelle, avec ses jeunes et anciennes générations, aide à optimiser les performances.
  • Faites attention aux fuites de mémoire et utilisez des outils comme WeakReference pour les besoins spécifiques de mise en cache.
  • Les options JVM de base comme -Xmx et -Xms contrôlent la taille du tas.

Nous allons maintenant approfondir les outils de profilage afin d'identifier les goulots d'étranglement !

Questions Fréquemment Posées

La leçon « Gestion de la mémoire et optimisation du GC » est-elle gratuite ?

Oui — le texte complet de « Gestion de la mémoire et optimisation du GC » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Scala for Backend Engineering & Functional Programming, passe à CoddyKit PRO. Le cours Scala for Backend Engineering & Functional Programming comprend 3 leçons au total.

Qu'est-ce que j'apprendrai dans « Gestion de la mémoire et optimisation du GC » ?

Explorez en profondeur la gestion de la mémoire de la JVM, le ramasse-miettes et les techniques d’optimisation de l’utilisation de la mémoire en Scala. Tu pratiques Scala for Backend Engineering & Functional Programming avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Scala for Backend Engineering & Functional Programming ?

Aucune expérience préalable n'est requise. Scala for Backend Engineering & Functional Programming sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 3.

Combien de temps prend la leçon « Gestion de la mémoire et optimisation du GC » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Scala for Backend Engineering & Functional Programming ?

Oui. Chaque leçon Scala for Backend Engineering & Functional Programming inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Profilage des applications Scala
  2. Gestion de la mémoire et optimisation du GC
  3. Optimisation du code concurrent
← Retour à Scala for Backend Engineering & Functional Programming