Confirm that the Native Memory problem is manifested as normal heap memory but the total process memory is growing, the RES memory is far beyond the -Xmx setting, and an OOM error with Direct buffer or native thread. 1. Use NMT (-XX:NativeMemoryTracking=summary) to track the native memory of JVM, and view the memory trends of modules such as Thread and Internal through jcmd; 2. Pay attention to the leakage of Direct Buffer, use allocateDirect() to not release or the MaxDirectMemorySize setting is unreasonable; 3. Check that too many threads lead to high stack space occupancy, and adjust the thread stack size through -Xss; 4. Troubleshoot the problem of not releasing JNI or third-party library resources, and analyze it in combination with Profiling tools; 5. Use pstack/jstack, valgrind/Massif, VisualVM plug-in and perf to in-depth diagnosis, and use Prometheus Grafana to container environments Monitor RES changes.

Java applications usually encounter memory problems. Most developers are familiar with monitoring and tuning of heap memory, but the problems with Native Memory are easily overlooked. Once native memory leaks or overflows occur, troubleshooting is more complicated. Below are some practical methods and tools to help you diagnose Native Memory problems in Java.

How to confirm that it is a Native Memory problem?

The memory used by Java processes not only includes heap memory (Heap), but also non-heap memory (Non-Heap) and native memory. If you find:

• Heap memory is used normally, but the total process memory continues to grow
• Use top or htop to see that the RES memory occupied by the Java process is much larger than -Xmx setting value
• OutOfMemoryError OutOfMemoryError: Direct buffer memory or OutOfMemoryError: unable to create new native thread

All of these may be something wrong with Native Memory.

At this time, don’t just focus on the heap memory, change your thinking and start from the system level.

Enable Native Memory Tracking: NMT

JDK comes with a very useful tool called Native Memory Tracking (NMT for short). It can count the native memory used by the JVM itself.

The enable method is very simple, add:

 -XX:NativeMemoryTracking=[summary|summary,shutdown|detailed]

for example:

 java -XX:NativeMemoryTracking=summary -jar your_app.jar

You can then view it through the command:

 jcmd <pid> VM.native_memory

The memory usage of different modules will be listed in the output result, such as:

• Java Heap
• Thread
• Code
• GC
• Internal
• Malloced
• Arena Chunk

Focus on growth trends in Thread and Internal modules. If these two parts continue to rise, it is likely that it is a thread leak or some native resources are not released.

Common reasons for Native Memory growth

1. Direct Buffer Leak

   • The memory allocated using ByteBuffer.allocateDirect() belongs to Native Memory.
   • If not closed or recycled correctly, memory accumulation can occur.
   • The upper limit can be controlled by -XX:MaxDirectMemorySize .

2. Too many threads

   • Each thread allocates a certain size of stack space by default (usually 1MB).
   • If the application creates a large number of threads, native memory will also skyrocket.
   • The thread stack size can be adjusted by -Xss , but not too small, otherwise StackOverflowError may be triggered.

3. Improper use of JNI or third-party libraries

   • When using JNI or libraries that rely on native implementations such as Netty and FFmpeg, if resources are not released, it may also cause leakage.
   • This type of problem generally needs to be further analyzed by referring to the specific library documentation or using the Profiling tool.

Cooperate with other tools to assist in diagnosis

In addition to NMT, you can also conduct in-depth investigations with the following tools:

• pstack / jstack : Check the thread status and determine whether there are a large number of threads in the new or blocked state.
• valgrind / Massif (Linux): Can be used to detect memory leaks in the native layer, suitable for C/C extensions or embedded scenarios.
• VisualVM Native Memory Tracker Plugin : Graphically demonstrates Native Memory usage.
• perf : used to analyze CPU and memory hotspots.

If it is a container environment, you can also use Prometheus Grafana to monitor the RES memory trends.

Basically these methods and tools. Troubleshooting Native Memory problems is not as intuitive as heap memory, but it actually has traces to follow. The key is to first confirm whether this type of problem is, and then use appropriate tools to locate the root cause.

The above is the detailed content of Java Native Memory Diagnostics and Tools. For more information, please follow other related articles on the PHP Chinese website!