JVM常见的问题可以简单的总结为三大类:
- StackOverFlowError
- Memory Leaks: OutOfMemoryError作为典型代表,造型十分标准(要说明的是内存泄漏的结果往往是OOM,而OOM多种多样,不一定都是内存泄漏)
- System Crash
StackOverFlowError这条线,一个知道jvm线程栈的逻辑结构,栈大小(-Xss或-XX:ThreadStackSize),另外jvm内部实现这块内存的normal page、yellow page、red page、shadow page及其代表的含义,抛隐式异常、crash日志、core dump的处理方式,最多再去了解crash日志中Current Thread的地址,问题frame时的栈顶指针地址,要定位这类问题,不难。
至于OutOfMemory类型比较多,和System Crash建议直接从Oracle官网hotspot troubleshoot入门,线上出问题仔细追几次,这一类总结下来,也十分酸爽。
Understand the OutOfMemoryError Exception
java.lang.OutOfMemoryError
error is thrown when there is insufficient space to allocate an object in the Java heap.
One common indication of a memory leak is the java.lang.OutOfMemoryError
exception. In this case, The garbage collector cannot make space available to accommodate a new object, and the heap cannot be expanded further. Also, this error may be thrown when there is insufficient native memory to support the loading of a Java class. In a rare instance, a java.lang.OutOfMemoryError
can be thrown when an excessive amount of time is being spent doing garbage collection, and little memory is being freed.
When a java.lang.OutOfMemoryError
exception is thrown, a stack trace is also printed.
The java.lang.OutOfMemoryError
exception can also be thrown by native library code when a native allocation cannot be satisfied (for example, if swap space is low).
An early step to diagnose an OutOfMemoryError
exception is to determine the cause of the exception. Was it thrown because the Java heap is full, or because the native heap is full? To help you find the cause, the text of the exception includes a detail message at the end, as shown in the following exceptions.
Exception in thread thread_name: java.lang.OutOfMemoryError: Java heap space
Cause: The detailed message Java heap space indicates that an object could not be allocated in the Java heap. This error does not necessarily imply a memory leak. The problem can be as simple as a configuration issue, where the specified heap size (or the default size, if it is not specified) is insufficient for the application.
In other cases, and in particular for a long-lived application, the message might be an indication that the application is unintentionally holding references to objects, and this prevents the objects from being garbage collected. This is the Java language equivalent of a memory leak. Note:The APIs that are called by an application could also be unintentionally holding object references.
One other potential source of this error arises with applications that make excessive use of finalizers. If a class has a finalize
method, then objects of that type do not have their space reclaimed at garbage collection time. Instead, after garbage collection, the objects are queued for finalization, which occurs at a later time. In the Oracle Sun implementation, finalizers are executed by a daemon thread that services the finalization queue. If the finalizer thread cannot keep up with the finalization queue, then the Java heap could fill up, and this type of OutOfMemoryError
exception would be thrown. One scenario that can cause this situation is when an application creates high-priority threads that cause the finalization queue to increase at a rate that is faster than the rate at which the finalizer thread is servicing that queue.
Action: To know more about how to monitor objects for which finalization is pending Monitor the Objects Pending Finalization.
Exception in thread thread_name: java.lang.OutOfMemoryError: GC Overhead limit exceeded
Cause: The detail message "GC overhead limit exceeded" indicates that the garbage collector is running all the time, and the Java program is making very slow progress. After a garbage collection, if the Java process is spending more than approximately 98% of its time doing garbage collection and if it is recovering less than 2% of the heap and has been doing so for the last 5 (compile time constant) consecutive garbage collections, then a java.lang.OutOfMemoryError
is thrown. This exception is typically thrown because the amount of live data barely fits into the Java heap having little free space for new allocations.
Action: Increase the heap size. The java.lang.OutOfMemoryError
exception for GC Overhead limit exceeded can be turned off with the command-line flag -XX:-UseGCOverheadLimit
.
Exception in thread thread_name: java.lang.OutOfMemoryError: Requested array size exceeds VM limit
Cause: The detail message "Requested array size exceeds VM limit" indicates that the application (or APIs used by that application) attempted to allocate an array that is larger than the heap size. For example, if an application attempts to allocate an array of 512 MB, but the maximum heap size is 256 MB, then OutOfMemoryError
will be thrown with the reason “Requested array size exceeds VM limit."
Action: Usually the problem is either a configuration issue (heap size too small) or a bug that results in an application attempting to create a huge array (for example, when the number of elements in the array is computed using an algorithm that computes an incorrect size).
Exception in thread thread_name: java.lang.OutOfMemoryError: Metaspace
Cause: Java class metadata (the virtual machines internal presentation of Java class) is allocated in native memory (referred to here as metaspace). If metaspace for class metadata is exhausted, a java.lang.OutOfMemoryError
exception with a detail MetaSpace
is thrown. The amount of metaspace that can be used for class metadata is limited by the parameter MaxMetaSpaceSize
, which is specified on the command line. When the amount of native memory needed for a class metadata exceeds MaxMetaSpaceSize
, a java.lang.OutOfMemoryError
exception with a detail MetaSpace
is thrown.
Action: If MaxMetaSpaceSize
, has been set on the command-line, increase its value. MetaSpace
is allocated from the same address spaces as the Java heap. Reducing the size of the Java heap will make more space available for MetaSpace
. This is only a correct trade-off if there is an excess of free space in the Java heap. See the following action for Out of swap space detailed message.
Exception in thread thread_name: java.lang.OutOfMemoryError: request size bytes for reason. Out of swap space?
Cause: The detail message "request size bytes for reason. Out of swap space?" appears to be an OutOfMemoryError
exception. However, the Java HotSpot VM code reports this apparent exception when an allocation from the native heap failed and the native heap might be close to exhaustion. The message indicates the size (in bytes) of the request that failed and the reason for the memory request. Usually the reason is the name of the source module reporting the allocation failure, although sometimes it is the actual reason.
Action: When this error message is thrown, the VM invokes the fatal error handling mechanism (that is, it generates a fatal error log file, which contains useful information about the thread, process, and system at the time of the crash). In the case of native heap exhaustion, the heap memory and memory map information in the log can be useful. See Fatal Error Log.
If this type of the OutOfMemoryError
exception is thrown, you might need to use troubleshooting utilities on the operating system to diagnose the issue further. See Native Operating System Tools.
Exception in thread thread_name: java.lang.OutOfMemoryError: Compressed class space
Cause: On 64-bit platforms, a pointer to class metadata can be represented by 32-bit offset (with UseCompressedOops
). This is controlled by the command line flag UseCompressedClassPointers
(on by default). If the UseCompressedClassPointers
is used, the amount of space available for class metadata is fixed at the amount CompressedClassSpaceSize
. If the space needed for UseCompressedClassPointers
exceeds CompressedClassSpaceSize
, a java.lang.OutOfMemoryError
with detail Compressed class space is thrown.
Action: Increase CompressedClassSpaceSize
to turn off UseCompressedClassPointers
. Note: There are bounds on the acceptable size of CompressedClassSpaceSize
. For example -XX: CompressedClassSpaceSize=4g
, exceeds acceptable bounds will result in a message such as
CompressedClassSpaceSize
of 4294967296 is invalid; must be between 1048576 and 3221225472.
Note:
There is more than one kind of class metadata,
–klass
metadata, and other metadata. Onlyklass
metadata is stored in the space bounded byCompressedClassSpaceSize
. The other metadata is stored inMetaspace
.
Exception in thread thread_name: java.lang.OutOfMemoryError: reason stack_trace_with_native_method
Cause: If the detail part of the error message is "reason stack_trace_with_native_method, and a stack trace is printed in which the top frame is a native method, then this is an indication that a native method, has encountered an allocation failure. The difference between this and the previous message is that the allocation failure was detected in a Java Native Interface (JNI) or native method rather than in the JVM code.
Action: If this type of the OutOfMemoryError
exception is thrown, you might need to use native utilities of the OS to further diagnose the issue. See Native Operating System Tools.
原文链接:https://docs.oracle.com/javase/10/troubleshoot/troubleshoot-memory-leaks.htm#JSTGD276