Analyzing Java heap dumps is a key means to troubleshoot memory problems, especially for identifying memory leaks and performance bottlenecks. 1. Use Eclipse MAT or VisualVM to open the .hprof file. MAT provides Histogram and Dominator Tree views to display the object distribution from different angles; 2. sort in Histogram by number of instances or space occupied to find classes with abnormally large or large sizes, such as byte[], char[] or business classes; 3. View the reference chain through "List Objects > with incoming/outgoing references" to determine whether it is accidentally held; 4. Use the "Path to GC Roots" function to eliminate virtual/soft/weak references, locate strong reference paths, and identify problems such as uncleaned cache, unlogged listeners, improper use of ThreadLocal; 5. Use Dominator Tree Check the Retained Heap value, determine which objects can free up a lot of memory after being released, and further expand the dominant area to analyze the overall memory structure. Mastering these key steps can quickly locate most memory problems.

Analyzing Java heap dumps is an important means to troubleshoot memory problems, especially when dealing with memory leaks or performance bottlenecks. The core is to find out memory-occupying objects, duplicate objects or unexpected reference chains through tools.

Open Heap Dump with the right tools

The most common tools are Eclipse MAT (Memory Analyzer) and VisualVM , where MAT is more powerful and suitable for in-depth analysis.
After downloading and installing, use it to open the .hprof file directly to start browsing the heap memory situation.

• MAT will display views such as "Histogram" and "Dominator Tree", respectively, displaying the object distribution from different angles.
• If you just want to see how many instances a certain class has, Histogram is the first choice.
• If you want to know which objects take up the most memory and prevent garbage collection, Dominator Tree is more suitable.

Find large and duplicate objects in memory

After entering the Histogram view, you can sort it by the number of instances or the total footprint. Focus on classes with abnormal numbers or large sizes of a single instance.

for example:

• byte[] or char[] take up a high occupancy, which may be cached or large strings not released;
• The number of a certain business class (such as User and CacheEntry ) is far beyond expectations, and there may be memory leaks;
• Pay attention to the package name and prioritize checking the classes related to the code you wrote yourself.

Click in to see the specific instance, right-click and select "List Objects > with incoming/outgoing references", you can view the reference chain and determine whether it is accidentally held.

Analyze the reference chain and locate the root cause of memory leaks

Memory leaks are usually caused by the fact that objects are no longer used but cannot be recycled by GC. They are common in static collections, listeners, thread local variables, etc.

MAT provides the "Path to GC Roots" function to see why an object is still alive. The operation method is:

• Right-click the suspicious object
• Select "Merge Shortest Path to GC Roots" → Do not check "Virtual/Soft/Wind References", only look at the strong reference path

In this way, you can see who is "hugging" the object. Common "culprits" include:

• Cache not cleaned (especially HashMap without an expiration mechanism)
• Listener not logged out (such as event listening, observer mode)
• Improper use of ThreadLocal causes residual data in thread pool

Use Dominator Tree if necessary

Dominator Tree shows the relationship of "who controls who" that is, if object A is recycled, then all objects under it are recycled. This is very helpful in judging the overall memory structure.

In this view, you can see the "Retained Heap" value for each node, representing how much memory can be freed if the object is freed. The larger the value, the more you are worth paying attention to.

If you find that an object Retained Heap is particularly high, you can further expand its dominant area to see if multiple child objects are involved at the same time.

Basically that's it. Heap dump analysis is not particularly complicated, but it is easy to ignore details, such as reference types, real paths of GC Roots. Just grasp a few key views and operation methods to quickly locate most memory problems.

The above is the detailed content of How to analyze a Java heap dump?. For more information, please follow other related articles on the PHP Chinese website!