Pour configurer les paramètres JVM pour minimiser les pauses de collecte des ordures (GC), il est important de comprendre les opérations fondamentales de différents collecteurs de déchets et les mécanismes de réglage disponibles dans le JVM. Le processus de configuration consiste à sélectionner un algorithme de collecte de déchets approprié, à régler les tailles de tas, à configurer des buts de temps en pause, des paramètres de filetage et à optimiser les régions de mémoire. Vous trouverez ci-dessous une synthèse détaillée du réglage JVM pour minimiser les pauses GC basées sur des sources et les meilleures pratiques faisant autorité:
Choisir le bon collecteur de déchets
Le JVM propose plusieurs algorithmes de collecte de déchets, chacun avec différentes caractéristiques concernant le débit, les temps de pause et l'utilisation des ressources:
- Serial GC: utilise un seul thread pour GC. Il arrête tous les threads d'application pendant la collecte, entraînant de longues pauses. Il ne convient généralement pas pour minimiser les pauses dans des applications plus grandes.
- Parallel GC: utilise plusieurs threads pour effectuer la collecte des ordures, réduisant les temps de pause par rapport au GC en série en tirant parti de plusieurs noyaux de processeur. Il est orienté vers le débit mais pause les fils d'application pendant GC.
- Mark-Sweep (CMS) simultanément GC: effectue une grande partie du travail de collecte des ordures en même temps que l'application, réduisant considérablement les temps de pause en n'arrissant que brièvement l'application à des phases GC spécifiques. Il convient aux applications à faible latence.
- Garbage First (G1) GC: divise le tas en régions et se concentre sur la collecte des régions avec le plus d'ordures en premier. Il vise à fournir des temps de pause prévisibles et un bon débit en mélangeant des phases simultanées et parallèles. C'est souvent la valeur par défaut dans les versions JVM modernes.
- Shenandoah et ZGC: Ces collectionneurs à faible latence effectuent tout ou la plupart des GC fonctionnent simultanément, visant des pauses très courtes ou presque imperceptibles, adaptées à de grands tas et à des applications très réactives.
Le choix du bon collecteur dépend des exigences de l'application telles que le temps de pause toléré maximum, la taille du tas et les caractéristiques de la charge de travail.
Configuration de la taille du tas
La taille du tas a un impact direct sur la fréquence GC et les durées de pause:
- Réglez la taille du tas initiale et maximale égale: l'utilisation de `-xms` et` -xmx` avec la même valeur évite le redimensionnement du tas, qui peut introduire des pauses pendant l'exécution.
- Taille adéquate du tas: le tas de sous-allocation provoque des collections fréquentes, augmentant les pauses. Cependant, une sur-allocation conduit à des cycles GC plus longs. Recherchez un solde basé sur les besoins de la mémoire d'application.
- Surveillez les journaux GC et les mesures d'utilisation du tas pour régler la taille du tas de manière appropriée.
Contrôlant le temps de pause GC
The JVM provides parameters to set goals for maximum GC pause times:
- `-xx: maxgcpausemillis =`: définit un temps de pause maximum cible en millisecondes pour que le collecteur essaie de se rencontrer. Bien qu'il ne soit pas garanti, le JVM tente d'ajuster le débit et le GC pour éviter de dépasser ce temps de pause.
- Utilisez ce paramètre avec G1 GC ou d'autres collectionneurs qui prennent en charge les objectifs de temps en pause pour guider le JVM dans l'équilibrage du débit et de la latence.
Filation et parallélisme
Tirer parti de plusieurs fils pendant la collecte des ordures réduit les durées de pause:
- `-xx: parallelgcthreads =`: définit le nombre de threads utilisés pendant les phases parallèles de GC. Plus de threads peuvent réduire le temps de pause, mais peuvent également augmenter l'utilisation du processeur.
- `-xx: concgcthreads =`: pour les collectionneurs simultanés comme CMS et G1, définit le nombre de threads effectuant des phases simultanées.
- Le nombre optimal de threads devrait s'aligner sur le nombre de cœurs de CPU disponibles et la charge de travail; Les threads de sursouscription peuvent dégrader les performances.
réglage des tailles jeunes et vieilles génération
Le tas est généralement divisé en générations jeunes et vieux. Le réglage de leurs tailles affecte le comportement de GC:
- Taille de la jeune génération: une jeune génération plus grande réduit la fréquence des GC mineurs mais augmente les temps de pause GC mineurs. Ajustez en fonction du taux d'allocation des objets.
- Taille de l'ancienne génération: affecte la fréquence à laquelle les GC majeurs / complets fonctionnent et leur durée.
- G1 GC divise le tas en de nombreuses régions de taille égale et gère la taille dynamiquement, mais permet de régler les seuils d'initiation avec des paramètres comme `-xx: InitiantHeAPOCUPCUPancyPancyPrence».
Paramètres spécifiques du collecteur de déchets
Pour G1 GC, couramment utilisé dans les JVM modernes:
- `-xx: + useg1gc`: Active G1 GC.
- `-xx: maxgcpausemillis =`: cible de temps en pause.
- `-xx: InitiantHeapoCupancypercent =`: commence le marquage simultané lorsque le tas atteint cette occupation.
- `-xx: + usestringDeduplication`: réduit l'empreinte de la mémoire en dédupliquant les chaînes.
- Évitez de fixer explicitement la taille de la jeune génération, car elle peut interférer avec les objectifs de temps en pause de G1.
Pour CMS GC:
- `-xx: + useConcMarksweepgc`: Active CMS.
- Le réglage se concentre sur la réduction des pauses globales d'arrêt du monde en ajustant le seuil d'initiation et le nombre de threads.
Pour GC parallèle (orienté vers le débit):
- `-xx: + useParallelgc` et` -xx: + useParalleLoldgc`: Active GC parallèle pour les générations jeunes et anciennes.
- Assurez le nombre de threads GC avec `-xx: parallelgcthreads`.
Réduire le taux d'allocation d'objets
Réduire la vitesse à laquelle les nouveaux objets sont créés réduisent la pression GC:
- Profil et optimiser le code pour minimiser la création d'objets inutile.
- Utilisez la mise en commun des objets et la réutilisation lorsque cela est possible.
- Ajustez les paramètres JVM pour réguler les régions de mémoire interne pour de meilleurs modèles d'allocation d'objets.
Évitez les appels GC explicites
- Désactiver les appels GC explicites à partir du code d'application ou des outils externes qui peuvent déclencher des pauses GC complètes à l'aide de `-xx: + DisableExplicitGC`.
Surveillance et journalisation
Pour comprendre et régler le comportement GC, activez la journalisation GC détaillée:
- Utilisez `-xlog: gc *` dans JVMS prenant en charge la journalisation unifiée (Java 9+).
- Dans les anciennes JVM, utilisez `-xx: + printgcdetails -xx: + printgcdatestamps -xloggc:`.
Analyser les journaux pour identifier les causes de pause et régler en conséquence.
Recommandations générales
- Commencez à régler une ardoise propre en supprimant les arguments JVM obsolètes.
- Test des changements dans un environnement de production.
- Utilisez des outils tels que Java Flight Recorder, VisualVM ou Profilers commerciaux pour collecter des données GC et d'utilisation de la mémoire.
- Itérer les étapes de réglage basées sur les temps de pause GC observés, le débit et la réactivité de l'application.
En résumé, minimiser les pauses de collecte de déchets JVM implique la sélection du collecteur de déchets approprié (de préférence G1, ZGC ou Shenandoah pour les exigences de faible pause), le tas de dimensionnement et les générations correctement, la définition des objectifs de temps de pause, le réglage des fils de concurrence, la minimisation du taux d'allocation d'objets, la désactivation des GC explicites et la surveillance prudente. Les spécificités dépendront de la charge de travail de l'application, de la taille du tas, de la version JVM et des caractéristiques matérielles. Les ajustements doivent être effectués progressivement et validés avec des outils de surveillance et des journaux GC détaillés pour atteindre l'équilibre de débit et le temps de pause souhaité.
Cette approche garantit que la collection d'ordures de JVM fonctionne efficacement avec des perturbations minimales des performances de l'application.