Déboguer et surveiller l'application Java avec VisualVM et jstack-javaDidacticiel-php.cn

Les applications Java, en particulier celles exécutées en production, peuvent développer des goulots d'étranglement, des blocages et des fuites de mémoire qui peuvent être difficiles à retracer. Lorsque ces problèmes surviennent, un débogage rapide et efficace est essentiel pour assurer le bon fonctionnement des applications et maintenir une expérience utilisateur positive. C'est là que VisualVM et JStack deviennent des outils précieux pour les développeurs Java.

VisualVM, avec ses puissantes capacités de profilage et de surveillance, et jstack, offrant des thread dumps détaillés, forment un duo dynamique qui permet aux développeurs de détecter, diagnostiquer et déboguer des problèmes complexes avec facilité.

Le diagnostic et la résolution des blocages sont essentiels, en particulier dans les applications hautes performances. Ce guide explorera comment détecter les blocages et obtenir des thread dumps à l'aide de deux outils Java puissants : VisualVM et jstack.

1. Comprendre les blocages et les vidages de threads

Avant de plonger dans les outils, clarifions quelques bases :

Deadlock : Une situation dans laquelle les threads attendent les uns les autres pour libérer des ressources, conduisant à un cycle de blocage indéfini.

Thread Dump : un instantané des threads actifs dans une application Java à un moment donné, y compris des détails sur leurs états et les verrous qu'ils détiennent ou attendent. Un vidage de thread est crucial pour analyser et identifier les sources de blocage dans les applications Java, permettant aux développeurs d'identifier la cause des threads bloqués.

2. Introduction à VisualVM

VisualVM est un outil visuel intégrant plusieurs outils JDK en ligne de commande pour fournir un aperçu complet des applications Java. Il est largement utilisé pour surveiller et profiler les applications, diagnostiquer les fuites de mémoire et analyser les performances.

Principales fonctionnalités

Surveillance et profilage en direct
Analyse des fils
Informations sur l'utilisation de la mémoire et du processeur
Dumps de threads pour l'analyse des blocages

Déboguer à l'aide de VisualVM (pour les applications Java)

Télécharger VisualVM
Ouvrez VisualVM.
Connectez-vous au processus JVM en cours d'exécution.
Dans les outils de surveillance, vous pouvez cliquer sur Thread dump ou afficher les détails du fil de discussion en temps réel.

Debug and Monitor Java App with VisualVM and jstack

3. Introduction à jstack

jstack est un outil de ligne de commande inestimable pour tout développeur Java traitant d'applications complexes qui s'appuient fortement sur les threads. En fournissant des informations détaillées sur les états des threads, le comportement de verrouillage et le flux d'exécution, jstack simplifie le processus de débogage, facilitant ainsi la détection et la résolution des problèmes tels que les blocages, les goulots d'étranglement des performances et le blocage des applications.

Principales fonctionnalités

jstack affiche l'état de chaque thread, tel que RUNNABLE, BLOCKED, WAITING ou TIMED_WAITING.
Capturez les traces de pile pour les processus en direct ou bloqués pour aider au débogage des problèmes de thread complexes.
jstack marque les threads bloqués dans le thread dump, vous permettant de les identifier rapidement.
Obtenez un vidage de thread, qui répertorie tous les threads actifs dans la JVM.
Associé à d'autres outils comme VisualVM ou jmap, jstack peut aider à retracer les fuites de mémoire jusqu'aux threads responsables de la création excessive d'objets ou de la conservation de références.
En analysant les thread dumps, les développeurs peuvent identifier les problèmes de synchronisation, les blocages excessifs ou les opportunités de réduire les conflits, ce qui améliore la concurrence et la réactivité.

Utiliser jstack pour obtenir et analyser les threads dumps

Pour capturer un thread dump d'une application Java en cours d'exécution à l'aide de jstack, vous aurez besoin de l'ID de processus (PID) du processus Java. Voici un guide étape par étape :

Étape 1 : Recherchez l'ID de processus (PID) de l'application Java

C:\Program Files\Java\jdk-21\bin>jps -l
12912
22480 org.springframework.ide.vscode.boot.app.BootLanguageServerBootApp
24020 jdk.jcmd/sun.tools.jps.Jps
14344 org/netbeans/Main
21944 deadlock/deadlock.DeadlockExample

Copier après la connexion

Étape 2 : Utilisez jstack pour capturer le thread Dump

C:\Program Files\Java\jdk-21\bin>jstack 21944
2024-11-02 11:12:18
Full thread dump Java HotSpot(TM) 64-Bit Server VM (21.0.5+9-LTS-239 mixed mode, sharing):

Threads class SMR info:
.
..
....
...

"Thread-0" #29 [18484] prio=5 os_prio=0 cpu=0.00ms elapsed=1896.34s tid=0x000001bb3395ac40 nid=18484 waiting for monitor entry  [0x00000099227ff000]
   java.lang.Thread.State: BLOCKED (on object monitor)
        at deadlock.DeadlockExample.lambda(deadlock/DeadlockExample.java:23)
        - waiting to lock <0x000000070d03c740> (a java.lang.Object)
        - locked <0x000000070d05a828> (a java.lang.Object)
        at deadlock.DeadlockExample$$Lambda/0x000001bb350019f8.run(deadlock/Unknown Source)
        at java.lang.Thread.runWith(java.base@21.0.5/Thread.java:1596)
        at java.lang.Thread.run(java.base@21.0.5/Thread.java:1583)

"Thread-1" #30 [23240] prio=5 os_prio=0 cpu=0.00ms elapsed=1896.34s tid=0x000001bb3395b2a0 nid=23240 waiting for monitor entry  [0x00000099228ff000]
   java.lang.Thread.State: BLOCKED (on object monitor)
        at deadlock.DeadlockExample.lambda(deadlock/DeadlockExample.java:41)
        - waiting to lock <0x000000070d05a828> (a java.lang.Object)
        - locked <0x000000070d03c740> (a java.lang.Object)
        at deadlock.DeadlockExample$$Lambda/0x000001bb35001c08.run(deadlock/Unknown Source)
        at java.lang.Thread.runWith(java.base@21.0.5/Thread.java:1596)
        at java.lang.Thread.run(java.base@21.0.5/Thread.java:1583)

...
.....
..
Found one Java-level deadlock:
=============================
"Thread-0":
  waiting to lock monitor 0x000001bb117727a0 (object 0x000000070d03c740, a java.lang.Object),
  which is held by "Thread-1"

"Thread-1":
  waiting to lock monitor 0x000001bb11772500 (object 0x000000070d05a828, a java.lang.Object),
  which is held by "Thread-0"

Java stack information for the threads listed above:
===================================================
"Thread-0":
        at deadlock.DeadlockExample.lambda(deadlock/DeadlockExample.java:23)
        - waiting to lock <0x000000070d03c740> (a java.lang.Object)
        - locked <0x000000070d05a828> (a java.lang.Object)
        at deadlock.DeadlockExample$$Lambda/0x000001bb350019f8.run(deadlock/Unknown Source)
        at java.lang.Thread.runWith(java.base@21.0.5/Thread.java:1596)
        at java.lang.Thread.run(java.base@21.0.5/Thread.java:1583)
"Thread-1":
        at deadlock.DeadlockExample.lambda(deadlock/DeadlockExample.java:41)
        - waiting to lock <0x000000070d05a828> (a java.lang.Object)
        - locked <0x000000070d03c740> (a java.lang.Object)
        at deadlock.DeadlockExample$$Lambda/0x000001bb35001c08.run(deadlock/Unknown Source)
        at java.lang.Thread.runWith(java.base@21.0.5/Thread.java:1596)
        at java.lang.Thread.run(java.base@21.0.5/Thread.java:1583)

Found 1 deadlock.

Copier après la connexion

Note

jstack est disponible dans le JDK, alors assurez-vous que le JDK est installé et accessible dans votre environnement.
L'utilisation de jstack sur certains systèmes peut nécessiter des privilèges d'administrateur.
Utilisation de jstack -l 12345 > threaddump.txt enregistre le thread dump dans un fichier appelé threaddump.txt.

Sortie

VisualVM et jstack sont deux outils essentiels de la boîte à outils du développeur Java pour diagnostiquer et dépanner les applications Java, en particulier lorsqu'il s'agit de problèmes de performances, de blocages et de goulots d'étranglement de threads.

Ensemble, VisualVM et jstack offrent une approche complète du débogage des applications Java, avec VisualVM fournissant des informations détaillées sur les performances en temps réel et jstack permettant une analyse approfondie au niveau des threads. Leur utilisation combinée permet aux développeurs de diagnostiquer et de résoudre efficacement des problèmes Java complexes dans les environnements de développement et de production.