Types de garbage collector en Java

Les types de garbage collector Java définissent le type que nous utilisons pour développer le programme. Le garbage collection est une fonctionnalité importante de Java. En Java, nous utilisons le garbage collection pour libérer de la mémoire qui n'est plus utilisée. Le garbage collector suit tous les objets encore utilisés et marque le reste des objets comme des déchets. Le garbage collector utilise l'algorithme de balayage et de marquage.

En Java, le garbage collection n'est rien d'autre que la gestion de la mémoire ; nous faisons la même chose en utilisant JVM. En utilisant le garbage collection, nous n'avons pas besoin de gérer l'allocation et la désallocation d'un objet à l'aide d'un programmeur. Dans l'application Java, l'application alloue et libère de la mémoire en utilisant le système d'exploitation, et nous fournissons la même chose à partir de l'application et du garbage collection de nouvelles variables.

Commencez votre cours de développement de logiciels libres

Développement Web, langages de programmation, tests de logiciels et autres

Java propose plusieurs garbage collectors, qui répondent aux différents besoins de l'application. Choisir le bon garbage collector pour notre application est très important pour améliorer les performances de notre application. Java propose plusieurs types de garbage collector pour répondre aux besoins de l'application.

Points clés à retenir

• Parallel GC en Java est connu comme le garbage collector par défaut utilisé dans JVM. Le fonctionnement du GC parallèle est le même que celui du GC série.
• Le garbage collector série est adapté aux environnements monothread. Il utilise un seul thread pour GC.

Types de garbage collector Javas

Vous trouverez ci-dessous les types de garbage collector Java.

Nous utilisons ces types selon nos exigences comme suit ;

• Éboueur en série
• Éboueur parallèle
• Éboueur de balayage de marques simultanées
• Éboueur G1
• Éboueur Epsilon
• Z garbage collector
• Éboueur de Shenandoah

Le fonctionnement et les performances de chaque éboueur sont différents ; il contient ses propres avantages et inconvénients. Java nous permet de choisir n'importe quel garbage collector utilisé par JVM. Au moment de la sélection du garbage collector, nous devons transmettre les arguments de la JVM.

1. Collecteur de déchets en série

Ce garbage collector fonctionne en conservant tous les threads de l'application. Nous pouvons donc dire que les threads de notre application se bloquent en utilisant le processus du garbage collector série ; ce processus est connu sous le nom de monde et arrête l'événement. Pour admettre l'utilisation d'un garbage collector série dans l'environnement serveur, nous pouvons utiliser la même chose dans des programmes simples.

Pour utiliser le garbage collector série, nous devons exécuter le –XX:+UseSerialGC dans l'argument de la JVM. Nous pouvons le préciser au moment de l'utilisation d'un ramasse-miettes en série.

2. Collecteur de déchets parallèle

La seule différence entre le GC parallèle et le GC série est que le GC parallèle utilise plusieurs threads, tandis que le GC série n'utilise qu'un seul thread. Nous utilisons le GC parallèle pour accélérer le débit de notre application ; ceci est également connu sous le nom de collecteur de débit.

Pour utiliser le garbage collector parallèle, nous devons utiliser le –XX:+UseParallelGC dans l'argument de la JVM. Les garbage collectors parallèles et série sont essentiels lors du développement d'applications Java.

3. Récupérateur de déchets CMS

Dans CMS GC, nous utilisons plusieurs threads, qui ont été utilisés pour le tas et l'analyse, qui marqueront l'expulsion des instances marquées. Ce type de GC ne gèle pas le thread d'application au moment du GC. Le thread du garbage collector s'exécute simultanément avec les threads de l'application.

En utilisant ce garbage collector, nous pouvons utiliser plusieurs processeurs pour un meilleur débit de notre application. Nous utilisons CMS GC si nous avons plus de CPU à utiliser. Pour utiliser le garbage collector CMS, nous devons alors utiliser le –XX:+UseParNewGC dans l'argument de la JVM. Nous utilisons cet argument de machine virtuelle Java lors de l'utilisation de ce garbage collector.

4. Éboueur G1

Le garbage collector G1 est utilisé si nous contenons plus de 4 Go de mémoire. Ce GC divise le tas en morceaux de taille égale et effectue le garbage collection parallèle sur le même segment, selon la priorité. Le garbage collector G1 montre la phase de marquage global.

En complétant la phase de marquage, ce garbage collector collecte les informations qui contiennent l'objet du garbage collector. Pour utiliser le garbage collector G1, nous devons alors utiliser le –XX:+UseG1GC dans l’argument de JVM.

5. Epsilon Garbage Collector

Il s'agit d'un ramasse-miettes passif ou non opérationnel. Ce garbage collector alloue de la mémoire pour l’application, mais il ne collectera pas les objets inutilisés. Lorsque l'application épuise le tas, la JVM s'arrêtera, nous pouvons donc dire que ce GC permet à l'application de manquer de mémoire ou de planter.

L'objectif principal de ce garbage collector est de gérer et de mesurer les performances de l'application. Ce garbage collector contient les programmes complexes qui s'exécutaient à l'intérieur du programme.

6. Z Garbage Collector

Ce garbage collector effectue tout le travail simultanément sans arrêter l'exécution de nos applications. Ce garbage collector gère un tas contenant la taille de plusieurs téraoctets.

Ce type de garbage collector effectue son cycle en threads. Il mettra en pause son application dans un délai moyen de 1 MS.

7. Éboueur de Shenandoah

Ce type de garbage collector utilise les régions de mémoire pour gérer les objets qui ne sont plus utilisés et ceux qui étaient prêts pour la compression. Ce garbage collector ajoute le pointeur de transfert à chaque tas, qui utilise le contrôle d'accès sur l'objet spécifié.

Arguments JVM

Vous trouverez ci-dessous les arguments pour les machines virtuelles Java. Nous utilisons ces arguments dans les garbage collector comme suit.

• –XX:ParallelGCThreads=: Cet argument contrôle le numéro de thread GC.
• –XX:MaxGCPauseMillis=: Cet argument spécifie le temps de pause maximum.
• –XX:GCTimeRatio=: Cet argument spécifie l'objectif de débit maximum.
• –XX:+UseSerialGC: Cet argument spécifie le garbage collector série.
• –XX:+UseParallelGC: Cet argument spécifie le garbage collector parallèle.
• –XX:+UseG1GC: Cet argument spécifie le garbage collector G1.
• –XX:+UseConcMarkSweepGC: Cet argument spécifie le garbage collector du CMS.
• –XX:ParallelCMSThreads: Cet argument spécifie le collecteur CMS et le nombre de threads que nous utilisons.
• -XX:InitiatingHeapOccupancyPercent=: Cet argument contrôle l'occupation du tas lors du démarrage du cycle simultané.
• -XX:G1MixedGCLiveThresholdPercent=: Lorsqu'un objet actif existe dans l'ancienne région, cet argument exclut sa valeur de l'objet GC.
• -XX:G1HeapWastePercent=: Cet argument précise le nombre de régions autorisées à gaspiller.

Conclusion

Java propose une variété de garbage collector pour répondre aux besoins de diverses applications. Choisir le bon ramasse-miettes pour notre application afin d’améliorer ses performances est essentiel. Le type de garbage collector Java définit le type de garbage collector que nous utiliserons lors du développement du programme. Java possède une fonctionnalité importante appelée garbage collection.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!