Décharges Java

Les Java Dumps sont des cœurs Java qui sont créés par erreur lorsque la machine virtuelle s'arrête de manière inattendue en raison de problèmes de réseau, d'une erreur de mémoire ou lorsque l'utilisateur initie tout type de combinaison de touches. Un Java Dump peut être créé facilement soit en appelant l'API Java Dump incorporée dans le code source de l'application, soit en fournissant directement l'option -Xdump:java via la ligne de commande. Java Dump fournit une aide à l'utilisateur final en fournissant des informations utiles pour le dépannage et le diagnostic de la cause première de l'arrêt qui se produit lorsque l'application cesse de s'exécuter de manière inattendue.

Commencez votre cours de développement de logiciels libres

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

Syntaxe

Il n'y a pas de syntaxe spécifique pour les dumps Java car le besoin de dumps Java dépend de la cause première du problème, qui peut varier, comme mentionné. Ainsi, ce flux de syntaxe se produit lorsque l'utilisateur doit diagnostiquer la cause première et souhaite effectuer une analyse à l'aide des outils jcmd simplement en envoyant les requêtes requises à la JVM, et il est obligatoire d'utiliser le même système au moment de l'exécution que celui utilisé pour l'envoi. cette requête à la machine et au programme Java. Ainsi, la syntaxe est définie comme suit :

jcmd <process_ id> GC.heap_dump <pathname_for_file>

où se trouvent les paramètres passés :

 : Il est utilisé pour fournir l'identifiant du processus en cours d'exécution avec le programme Java.

 : Nom du chemin auquel le fichier sera transmis comme mentionné.

Comment fonctionnent les dumps en Java ?

Le workflow pour Java Dumps est très intéressant dans la mesure où il fournit une aide considérable à l'utilisateur final ou au programmeur au moment d'un crash de la machine ou de tout arrêt inattendu du système pour diverses raisons mentionnées comme une panne de réseau, erreur de mémoire, etc. De plus, toute forme d'erreur entravant l'exécution du programme Java peut être enregistrée en utilisant Java Dumps pour le dépannage et le diagnostic de la cause première. Il existe certains scénarios basés sur le fonctionnement des Dumps en Java :

• Un scénario dans lequel l'application Java aurait pu planter en raison d'une erreur de protection générale et générerait automatiquement un fichier de vidage Java. Pour surmonter et comprendre la cause première, il est indispensable de comprendre le type de thread ou de connaître correctement le thread en cours d'exécution pour identifier facilement le problème.
• Un autre scénario peut être dû au manque de mémoire des tas Java, ce qui génère également automatiquement le dump Java.
• Un scénario peut être dû à une situation de blocage dans laquelle tous les threads visent à acquérir le même thread en tant que ressource en même temps.
• Il peut également y avoir un cas de blocage soudain où l'utilisateur aurait pu exécuter la combinaison de touches.
• Il existe plusieurs façons de gérer les scénarios ci-dessus, ce qui signifie trouver la cause première et détecter les exceptions, notamment de nombreux outils Java Dumps qui ont fourni une capacité de facilité et de flexibilité aux utilisateurs finaux en termes de débogage et de dépannage au moment du crash immédiat ou de toute autre situation peu préférée comme l'arrêt ou les événements OutOfMemory.

Il existe différentes manières de capturer tous les scénarios et leur cause profonde en utilisant les outils et technologies de dumps Java. Ils sont très utiles pour résoudre les problèmes liés aux fuites de mémoire et aux problèmes d’optimisation de la mémoire. Ils sont principalement stockés au format binaire dans des fichiers hprof qui peuvent être visualisés et analysés à l'aide des outils et technologies suivants comme :

• Utiliser des outils JDK comme jmap en fournissant l'ID de processus et le chemin de fichier appropriés en intégrant les outils.
• L'utilisation de jcmd, qui est responsable de l'exécution de la demande et de la réponse, sert la JVM lorsque la même machine dans la JVM est utilisée pour le vidage de tête afin de lire la cause première et l'accusé de réception.
• JVisualVM est également un outil faisant partie du JDK, qui est utilisé pour améliorer et fournit une aide pour examiner facilement les dumps Java.
• Il est également possible de capturer Dump automatiquement et par programme, puis d'obtenir le résultat en conséquence.

Exemple de dumps Java

Cet exemple montre le thread effectuant un blocage sur les ressources, et maintenant qu'ils ont acquis les verrous sur les ressources, il existe une possibilité d'analyse de ce blocage sur les ressources avec Java Dumps en utilisant la commande dans la mention de la ligne de commande.

public class Java_lock_Dump_Demo {
public static void main(String[] args) throws InterruptedException {
Object ob_a = new Object();
Object ob_b = new Object();
Object ob_c = new Object();
Thread Java_lock_Dump_DemoThread1 = new Thread (new       Java_lock_Dump_Demo_Sync_Thread(ob_a, ob_b ), "Java_lock_Dump_DemoThread1");
Thread Java_lock_Dump_DemoThread2 = new Thread (new Java_lock_Dump_Demo_Sync_Thread(ob_b, ob_c ), "Java_lock_Dump_DemoThread2");
Thread Java_lock_Dump_DemoThread3 = new Thread (new Java_lock_Dump_Demo_Sync_Thread(ob_c, ob_a ), "Java_lock_Dump_DemoThread3");
Java_lock_Dump_DemoThread1.start();
Thread.sleep(3000);
Java_lock_Dump_DemoThread2.start();
Thread.sleep(3000);
Java_lock_Dump_DemoThread3.start();
}
}
class Java_lock_Dump_Demo_Sync_Thread implements Runnable {
private Object ob_a;
private Object ob_b;
public Java_lock_Dump_Demo_Sync_Thread(Object ob_a, Object ob_b) {
this.ob_a = ob_a;
this.ob_b = ob_b;
}
@Override
public void run() {
String nm = Thread.currentThread().getName();
synchronized (ob_a) {
System.out.println(nm + " acquire_the_lock_on_first_resource " + ob_a);
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (ob_b) {
System.out.println(nm + " acquire_the_lock_on_second_resource " + ob_b);
}
System.out.println(nm + " Release_the_lock_for_second_object " + ob_b);
}
System.out.println(nm + " Release_the_lock_for_first_object " + ob_a);
System.out.println(nm + " Completed with the deadlock_test for acquiring the resource.");
}
}

Sortie :

Comment obtenir le dump du code compilé ci-dessus, cela peut être fait en utilisant les commandes suivantes :

• First, retrieve the process id using the following command in the command line: jsp
• Then, after getting the process id run the following command in the command line :

Jcmd<Process_id> GC.heap_dump <file-path>
jcmd 20528 GC.heap_dump C:\Users\adutta\eclipse-workspace\Matcher_Example\src

Conclusion

Java Dumps is considered a very interesting feature in java as It provides programmers and users with the ability to get out of the unwanted and unexpected situations at the time of halt in the running program as well as when the machine goes out of memory space. It also provides the user with detailed and proper content for the root cause or the troubleshooting issue.

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!