Shulou(Shulou.com)06/03 Report--

This article introduces the knowledge of "how to use JVM memory analysis tool MAT". In the operation of actual cases, many people will encounter such a dilemma, so let the editor lead you to learn how to deal with these situations. I hope you can read it carefully and be able to achieve something!

1 introduction

MAT is a very powerful memory analysis tool with plug-ins in Eclipse as well as a separate installation package. In memory analysis, as long as you get the hprof file that reflects the current device memory image, you can directly see the current memory information by opening it through MAT.

2 prepare MAT using 2.1

Download the stand-alone version of MAT at https://www.eclipse.org/mat/downloads.php, and decompress it after download. Find the MemoryAnalyzer.ini file, which contains a Xmx parameter, which represents the maximum memory usage. The default is 1024m. You can modify this parameter according to the size of the heap dump file.

2.2 prepare the heap dump file (Heap Dump)

A heap dump file (Heap Dump) is a snapshot (.hprof format) of the Java process at a certain time. It holds a lot of information when it triggers a snapshot, such as Java object and class information (usually a Full GC is triggered before the heap dump file is written).

Heap dump file information:

All object information, including object instances, member variables, primitive type values stored in the stack, and reference values of other objects stored in the heap.

All class information, including classloader, class name, parent class, static variables, etc.

The reference path from GC Root to all of these objects.

Thread information, including the thread's call stack and thread local variables (TLS) for this thread.

There are several ways to get heap dump files:

The jmap command can be executed in cmd: jmap-dump:format=b,file=.

If you want to automatically dump when a memory overflow occurs, you need to add the following JVM parameter:-XX:+HeapDumpOnOutOfMemoryError.

If you use the Ctrl+Break key combination to get the data actively, you need to add the following JVM parameter:-XX:+HeapDumpOnCtrlBreak.

Using HPROF Agent, you can generate Dump files at the end of program execution or when you receive a SIGOUT signal. The parameters configured in the virtual machine are as follows:-agentlib:hprof=heap=dump,format=b.

Get using JConsole.

Get it using the File-> Acquire Heap Dump function of Memory Analyzer Tools.

2.3 analyze heap dump files

After opening MAT, load the dump file, which looks something like this:

Two commonly used functions: Histogram and Leak Suspects.

2.3.1 Histogram

Histogram can list the objects in memory, the number of objects and their memory size, and can be used to locate which objects are still alive after Full GC and which objects account for most of the memory.

Class Name: class name, Java class name.

Objects: the number of objects in the class and how many objects have been created for this object.

Shallow Heap: the amount of memory occupied by the object itself, which does not contain the memory of the object it refers to, which is of little use in actual analysis. The Shallow Size of a regular object (not an array) is determined by the number and type of its member variables. The Shallow Size of an array is determined by the type of array elements (object type, base type) and the length of the array. The object members are all references, and the real memory is on the heap. It looks like a bunch of native byte [], char [], int [], and the memory of the object itself is very small.

Retained Heap: it is calculated by superimposing all the object sizes in Retained Set (a collection of objects that will be recycled by GC when the object is reclaimed). In other words, because X is released, the heap size occupied by all other released objects (including those that are released recursively). Retained Heap can more accurately reflect the actual size of an object.

Retained Heap example: an ArrayList object holds 100 objects, each taking up 16 bytes. If the list object is recycled, then 100 of these objects can also be recycled, reclaiming 16 million + X of memory, and X represents the shallow size of the ArrayList.

Select a Class from the above list, right-click List objects > with incoming references, and the new page will display the object information created through this class.

To continue selecting an object, right-click Path to GC Roots > *. Usually when troubleshooting * * memory leaks (usually because there are invalid references) * *, we will select exclude all phantom/weak/soft etc.references, which means to view the reference chain that excludes virtual / weak / soft references, because objects with virtual / weak / soft references can be directly recycled by GC What we need to see is whether an object still has a Strong reference chain (manually trigger GC before exporting Heap Dump). If so, it indicates that there is a memory leak, and then troubleshoot the specific reference.

At this point, you will get the path from GC Roots to the object, and through the references between objects, you can clearly see why the object has not been recycled, and then locate the problem. If the above object should have been dropped by GC at this time, the simple way is to dispose of one of them as null or remove, so that it has no path to GC Root and is in an unreachable state, and the garbage collector can collect it. Conversely, an object that exists in GC Root will not be reclaimed by the garbage collector.

2.3.2 Leak Suspects

Leak Suspects can automatically analyze and prompt for possible memory leaks, and can directly navigate to Class and the corresponding number of rows.

For example: the description of problem 1 here lists some larger examples. Click Details to see the details. You can also click See stacktrace to view specific thread stack information (you can directly navigate to a method in a specific class).

On the Details details page, Shortest Paths To the Accumulation Point represents the shortest path from GC root to the memory consumption aggregation point. If a memory consumption aggregation point has a path to GC root, the memory consumption aggregation point will not be collected as garbage.

Actual combat: in a project, several of the Tomcat responses are particularly slow. Open Java VisualVM to observe Tomcat (pid xxx)-Visual GC found that Spaces-Old rises, Graphs-GC Time is more frequent and lasts for a long time, and spikes appear (after a period of time after restart), and finally locate a query interface through the See stacktrace in Leak Suspects. After carefully examining the code, we found that there is a BUG: tens of thousands of data will be queried at one time under specific query conditions (because of dirty data), and return to normal after processing.

2.3.3 memory snapshot comparison

In order to find out the object of memory leak more efficiently, we usually get two heap dump files (one for dump and then one for dump). By comparing the results, it is easy to locate.

This is the end of "how to use the JVM memory analysis tool MAT". Thank you for reading. If you want to know more about the industry, you can follow the website, the editor will output more high-quality practical articles for you!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.