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

This article to share with you is about the use of memory analysis tool MAT, Xiaobian feel quite practical, so share to everyone to learn, I hope you can read this article after some harvest, not much to say, follow Xiaobian to see it.

MAT Tool Introduction

To do a good job, one must sharpen one's tools. Learning to use tools is also a skill. This article introduces a memory analysis tool used in my previous work.

MAT(Memory Analyzer Tool) is a JVM memory analysis tool, in the actual work can help us solve the problem of high memory consumption on generation.

I used MAT on eclipse before, the former is a plug-in for the latter. Later, I switched to IDEA and learned that MAT also has a separate and operational version. Its download address is as follows:

http://www.eclipse.org/mat/downloads.php

test code

Let's start with a simple piece of code that causes a JVM heap overflow so we can demonstrate the effect of MAT.

public static void main(String[] args) throws InterruptedException {

Map map = new HashMap();

int counter = 1;

while(true) {

Thread.sleep(10);

Tom tom = new Tom();

String [] friends = new String[counter];

for (int i = 0; i < friends.length; i++) {

friends[i] = "friends"+i;

}

tom.setAge(counter);

tom.setName("tom"+counter);

tom.setFriends(friends);

map.put(tom.getName(),tom);

if(counter0==0)

System.out.println("put"+counter);

counter++;

}

}

A very well understood piece of code, an infinite loop, constantly adding an object named Tom to the map, and the friends attribute of the object that comes out of each loop is constantly expanding.

Then we run the code using the startup parameter below,

-Xms200m -Xmx200m -XX:+HeapDumpOnOutOfMemoryError

The parameter specifies a heap memory size of 200m, which our test code will run out of quickly and then report an error.

Start the code, run for a while after the error as follows,

java.lang.OutOfMemoryError: GC overhead limit exceeded

Dumping heap to java_pid1398.hprof ...

Heap dump file created [239632332 bytes in 0.865 secs]

From this error we can get several information, the first is that the error type is memory overflow, the reason is beyond the GC limit.

Second, we see that the memory snapshot of the program error dumps into a file called java_pid1398.hprof. This file is a dump file that can be used for MAT tool analysis.

In addition to dumping memory files with the-XX:+HeapDumpOnOutOfMemoryError parameter above, you can export memory snapshots with the jmap command. I won't go into detail here.

memory analysis

We now analyze the problem in the code from several dimensions based on MAT analysis.

MAT tool opens the dump file in front of you, and you will see the following diagram first.

From the preview, you can see that one application consumes most of the total heap memory, up to 184 megabytes (the heap memory allocated by the program run is 200 megabytes). This shows that there must be a problem with this application, which is worth our further analysis.

Let's first look at the tool that gives us a judgment, find Leak Suspects, and click Go.

As you can see from the description, the main thread has a local variable that takes up a lot of memory. This variable is an instance of HashMap.

Haha, according to the above code, I have to say that MAT is still very awesome, and the location of the memory leak point is very accurate.

However, sometimes we still need to manually analyze it. We still go back to the previous preview page and find the Histogram point, as shown below:

Shallow heap refers to the size of memory occupied by the object itself, excluding the objects it references.

For non-array objects, its size is the sum of the size of the object and all its member variables. Of course, this will also include some java language features of the data storage unit.

For an array type object, its size is the sum of the sizes of the array element objects.

We see that the ones at the top of the list are the ones that take up a lot of memory,

char[] This is obviously caused by the reference in String (char[] is used to store data in string). Let's see who String is referenced by.

Clearly, the friends attribute of the Tom object consumes a lot of memory.

Here's the thing:

with incoming references is the object currently viewed, applied externally

with outGoing references indicates the current object, references external objects

Similarly, we can continue to analyze the following classes, and eventually we will find that the reason for the memory shortage is that the hashmap has been stuffed with a large number of Tom objects for a short time.

The above is how to use the memory analysis tool MAT. Xiaobian believes that some knowledge points may be seen or used in our daily work. I hope you can learn more from this article. For more details, please follow the industry information channel.

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.