In-depth analysis based on JavaCore files

Generation time

When a Java program is running, JavaCore and HeapDump files are sometimes generated. This usually occurs when the Java program encounters a fatal problem.

Sometimes after a fatal problem occurs, the Java application will not die and can continue to run;

But sometimes fatal problems occur and the Java process will die;

In order to retain the running state of the Java application before a fatal error occurs, the JVM generates two files before dying, namely JavaCore and HeapDump files.

What's the difference

JavaCore is about CPU, while HeapDump files are about memory.

The JavaCore file mainly saves the running position of each thread of the Java application at a certain moment, that is, which class, which method, and which line the JVM executes. It is a text file. After opening it, you can see the execution stack of each thread and display it as stack trace. By analyzing the JavaCore file, we can find out whether the application is "stuck" at a certain point, that is, it takes too long to run at a certain point, such as a database query that does not receive a response for a long time, eventually leading to a system crash.

The HeapDump file is a binary file that saves the usage of objects in the JVM heap at a certain time. This kind of file requires corresponding tools to analyze, such as tools such as IBM Heap Analyzer. The most important function of this type of file is to analyze whether there is a memory overflow in the system.

How to generate

These two files can be generated manually. When we encounter a situation where the system becomes slow or unresponsive, we can generate the JavaCore and HeapDump files manually.

On Unix/Linux, the method to generate these two files is as follows:

First, find out the Java process id, and then perform the 'kill -3 process number' operation. After the file is generated, do the same operation again to generate a set of files.

How to analyze

JavaCore file

The two sets of files are particularly effective when analyzing JavaCore, because it can see the execution position of the thread at two points in time. If it is found that the same thread is executed at the same position in the two sets of data, it means there may be a problem here. , because the program runs extremely fast. If it is at a certain point twice, it means that this point is very time-consuming. By analyzing these two files, we can find out the cause and solve the problem.

There is a "Current Thread Details" mark in the header of the JavaCore file, which records the thread ID of the system running when JavaCore is generated. Use the thread ID to find the detailed information of the thread in the file. This information records which class the thread is running and causes JavaCore.

In this way, the cause of the problem can be found by combining the log files at the time. However, this method can only find errors that are not memory overflow. For errors with java/lang/outMemoryException in the core file header, it still occurs when it is not known which class is executed.

HeapDump file
The HeapDump file is a snapshot of the Java stack at a specified time and is a kind of image file. The Heap Analyzer tool analyzes the HeapDump file to find out which objects occupy too much stack space to find objects that cause memory leaks or may cause memory leaks.