Introduction
Les paramètres de la JVM sont utilisés pour configurer la machine virtuelle Java (JVM), responsable de l'exécution du bytecode Java. En configurant correctement ces paramètres, nous pouvons améliorer les performances des applications Java. Dans ce laboratoire, nous apprendrons à définir certains paramètres JVM couramment utilisés pour optimiser les performances de vos applications.
Configuration de la mémoire tas (Heap Memory)
La mémoire tas (heap) est la zone de données d'exécution dans laquelle les objets Java sont alloués. Nous pouvons définir la taille de cette mémoire avec les paramètres -Xmx et -Xms.
-Xmx<heap size>[unit]: définit la taille maximale du tas.-Xms<heap size>[unit]: définit la taille initiale du tas.
Par exemple, pour définir la taille minimale du tas à 512 Mo et la taille maximale à 1 Go, nous pouvons utiliser la commande suivante :
java -Xms512m -Xmx1g MyApp
Choix des ramasse-miettes (Garbage Collectors)
Le ramasse-miettes (garbage collection) est le processus de libération de la mémoire occupée par des objets qui ne sont plus utilisés par l'application Java. Le choix du ramasse-miettes peut avoir un impact significatif sur les performances de l'application. La JVM propose plusieurs ramasse-miettes, chacun ayant ses propres forces et faiblesses.
-XX:+UseSerialGC: active le ramasse-miettes série, qui utilise un seul thread pour la collecte.-XX:+UseParallelGC: active le ramasse-miettes parallèle, qui utilise plusieurs threads pour la collecte.-XX:+UseParNewGC: active le ramasse-miettes concurrent-mark-sweep (CMS), qui utilise plusieurs threads pour effectuer une collecte simultanée.-XX:+UseG1GC: active le ramasse-miettes Garbage-first (G1), conçu pour offrir des temps de pause constants et un débit élevé.
Par exemple, pour activer le ramasse-miettes parallèle, nous pouvons utiliser la commande suivante :
java -XX:+UseParallelGC MyApp
Journalisation des activités du ramasse-miettes
La journalisation du ramasse-miettes nous permet de surveiller ses performances et d'ajuster ses paramètres en fonction des besoins de l'application. Nous pouvons utiliser les paramètres suivants pour activer cette journalisation :
-Xlog:gc*: active la journalisation du ramasse-miettes dans les versions récentes de Java.file=gc.log: écrit la sortie du journal dans un fichier nommégc.log.filecount=10: conserve jusqu'à 10 fichiers journaux pivotants.filesize=10M: fait pivoter le fichier journal après qu'il ait atteint 10 Mo.
Par exemple, pour activer la journalisation du ramasse-miettes et enregistrer le journal dans gc.log, nous pouvons utiliser la commande suivante :
java -Xlog:gc*:file=gc.log:time,uptime,level,tags:filecount=10,filesize=10M MyApp
Gestion des erreurs de mémoire insuffisante (Out of Memory)
Lorsque la JVM manque de mémoire, elle génère une erreur "Out Of Memory". Nous pouvons utiliser les paramètres JVM suivants pour gérer cette erreur :
-XX:+HeapDumpOnOutOfMemoryError: lorsque l'erreur survient, la JVM écrit un vidage du tas (heap dump) sur le disque.-XX:HeapDumpPath=<path to heap dump file>: spécifie le chemin du fichier de vidage du tas.-XX:OnOutOfMemoryError=<command>: lorsque l'erreur survient, la JVM exécute la commande spécifiée.-XX:+UseGCOverheadLimit: la JVM utilise cette option pour limiter le temps passé par le ramasse-miettes.
Par exemple, pour configurer la JVM afin qu'elle écrive un vidage du tas dans le fichier /path/to/heapdump.hprof en cas d'erreur de mémoire, nous pouvons utiliser la commande suivante :
java -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/path/to/heapdump.hprof MyApp
Utilisation d'une JVM 64 bits
Nous pouvons utiliser le paramètre -d pour sélectionner une JVM 32 bits ou 64 bits. Par exemple, pour utiliser la JVM 64 bits, nous pouvons utiliser la commande suivante :
java -d64 MyApp
Compilation et exécution d'une application Java avec des paramètres JVM
Utilisons le programme HelloWorld.java pour compiler et exécuter l'application Java avec les paramètres JVM appris précédemment.
cd ~/project
touch HelloWorld.java
Saisissez le code suivant :
class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello, World!");
}
}
Enregistrez le fichier et quittez. Maintenant, compilons et exécutons le code avec le paramètre -Xmx :
javac HelloWorld.java
java -Xmx512m HelloWorld
Cela définit la taille maximale du tas à 512 Mo. Vous devriez voir le résultat suivant :
Hello, World!
Compilation et exécution d'une application Java avec des ramasse-miettes
Maintenant, compilons et exécutons l'application Java avec le ramasse-miettes parallèle :
java -XX:+UseParallelGC HelloWorld
Vous devriez voir le résultat suivant :
Hello, World!
Compilation et exécution d'une application Java avec la journalisation du ramasse-miettes
Maintenant, compilons et exécutons l'application Java avec la journalisation du ramasse-miettes activée :
java -Xlog:gc*:file=gc.log:time,uptime,level,tags:filecount=10,filesize=10M HelloWorld
Cela écrit les journaux du ramasse-miettes dans gc.log dans le répertoire courant pendant l'exécution du programme.
Compilation et exécution d'une application Java avec d'autres paramètres fréquents
Maintenant, compilons et exécutons l'application Java avec les paramètres -XX:+UseStringDeduplication et -XX:MaxHeapFreeRatio :
java -XX:+UseStringDeduplication -XX:MaxHeapFreeRatio=70 HelloWorld
Cela active la déduplication des chaînes de caractères et définit le ratio maximal d'espace libre dans le tas après le ramasse-miettes à 70 %.
Résumé
Dans ce laboratoire, nous avons appris à définir divers paramètres JVM pour optimiser les performances des applications Java. Nous avons appris à configurer la taille de la mémoire tas, à choisir des ramasse-miettes, à activer la journalisation du ramasse-miettes, à gérer les erreurs de mémoire insuffisante, à utiliser une JVM 64 bits et à définir d'autres paramètres fréquemment utilisés. Nous avons également appris à compiler et à exécuter une application Java en utilisant ces paramètres JVM.
