深入理解JVM--堆栈内存溢出、内存泄漏问题以及相关异常信息

雨点打透心脏的1/2处 2022-01-21 11:33 206阅读 0赞

**栈溢出(StackOverflowError)**  
程序所要求的栈深度过大导致，可以写一个死递归程序触发。  
**堆溢出(OutOfMemoryError:Java heap space)**  
分清内存溢出还是内存泄漏  
泄露则看对象如何被 GC Root 引用。  
溢出则通过 调大 -Xms，-Xmx参数。  
**直接内存溢出**  
无法创建本地线程（OutOfMemoryError:unable to create native thread）  
总容量不变，堆内存，非堆内存设置过大，会导致能给线程的内存不足。

注意每一个方法的上面的虚拟机参数  
一、堆溢出 创建对象时如果没有可以分配的堆内存，JVM就会抛出OutOfMemoryError:java heap space异常。  
堆溢出实例：

/** * VM Args: -Xms20m -Xmx20m -XX:+HeapDumpOnOutOfMemoryError */
    public static void main(String[] args) { 
        List<byte[]> list = new ArrayList<>();
        int i=0;
        while(true){ 
            list.add(new byte[5*1024*1024]);
            System.out.println("分配次数："+(++i));
        }
    }

运行结果：  
分配次数：1  
分配次数：2  
分配次数：3

java.lang.OutOfMemoryError: Java heap space  
Dumping heap to java\_pid2464.hprof …  
Heap dump file created \[16991068 bytes in 0.047 secs\]

Exception in thread “main” java.lang.OutOfMemoryError: Java heap space  
at com.ghs.test.OOMTest.main(OOMTest.java:16)

附：dump文件会在项目的根目录下生成

从上面的例子我们可以看出，在进行第4次内存分配时，发生了内存溢出。

二、栈溢出栈空间不足时，需要分下面两种情况处理：  
线程请求的栈深度大于虚拟机所允许的最大深度，将抛出StackOverflowError  
虚拟机在扩展栈深度时无法申请到足够的内存空间，将抛出OutOfMemberError  
附：当前大部分的虚拟机栈都是可动态扩展的。

1、栈空间不足——StackOverflowError实例

public class StackSOFTest { 
     
        int depth = 0;
     
        public void sofMethod(){ 
            depth ++ ;
            sofMethod();
        }
     
        public static void main(String[] args) { 
            StackSOFTest test = null;
            try { 
                test = new StackSOFTest();
                test.sofMethod();
            } finally { 
                System.out.println("递归次数："+test.depth);
            }
        }
    }

执行结果:  
递归次数：982  
Exception in thread “main” java.lang.StackOverflowError  
at com.ghs.test.StackSOFTest.sofMethod(StackSOFTest.java:8)  
at com.ghs.test.StackSOFTest.sofMethod(StackSOFTest.java:9)  
at com.ghs.test.StackSOFTest.sofMethod(StackSOFTest.java:9)  
……后续堆栈信息省略

我们可以看到，sofMethod()方法递归调用了982次后，出现了StackOverflowError。

2、栈空间不足——OutOfMemberError实例  
单线程情况下，不论是栈帧太大还是虚拟机栈容量太小，都会抛出StackOverflowError，导致单线程情境下模拟栈内存溢出不是很容易，不过通过不断的建立线程倒是可以产生内存溢出异常。

public class StackOOMTest { 
     
        public static void main(String[] args) { 
            StackOOMTest test = new StackOOMTest();
            test.oomMethod();
        }
     
        public void oomMethod(){ 
            while(true){ 
                new Thread(new Runnable() { 
                    @Override
                    public void run() { 
                        loopMethod();
                    }
                }).start();;
            }
        }
     
        private void loopMethod(){ 
            while(true){ 
     
            }
        }
    }

运行结果：  
……操作系统直接挂掉了

如果哪位大神能够成功模拟，还望指点一二。

三、直接内存溢出  
DirectMemory可以通过-XX:MaxDirectMemorySize指定，如果不指定，默认与Java堆的最大值(-Xmx指定)一样。  
NIO会使用到直接内存，你可以通过NIO来模拟，在下面的例子中，跳过NIO，直接使用UnSafe来分配直接内存。

public class DirectMemoryOOMTest { 
     
        /** * VM Args:-Xms20m -Xmx20m -XX：MaxDirectMemorySize=10m * @param args */
        public static void main(String[] args) { 
            int i=0;
            try { 
                Field field = Unsafe.class.getDeclaredFields()[0];
                field.setAccessible(true);
                Unsafe unsafe = (Unsafe) field.get(null);
                while(true){ 
                    unsafe.allocateMemory(1024*1024);
                    i++;
                }
            } catch (Exception e) { 
                e.printStackTrace();
            }finally { 
                System.out.println("分配次数："+i);
            }
        }
    }

运行结果：  
Exception in thread “main” java.lang.OutOfMemoryError  
at sun.misc.Unsafe.allocateMemory(Native Method)  
at com.ghs.test.DirectMemoryOOMTest.main(DirectMemoryOOMTest.java:20)  
分配次数：27953

无法创建本地线程  
最后我们在来看看java.lang.OutOfMemoryError:unable to create natvie thread这种错误。 出现这种情况的时候，一般是下面两种情况导致的：

程序创建的线程数超过了操作系统的限制。对于Linux系统，我们可以通过ulimit -u来查看此限制。  
给虚拟机分配的内存过大，导致创建线程的时候需要的native内存太少。  
我们都知道操作系统对每个进程的内存是有限制的，我们启动Jvm,相当于启动了一个进程，假如我们一个进程占用了4G的内存，那么通过下面的公式计算出来的剩余内存就是建立线程栈的时候可以用的内存。线程栈总可用内存=4G-（-Xmx的值）- （-XX:MaxPermSize的值）- 程序计数器占用的内存  
通过上面的公式我们可以看出，-Xmx 和 MaxPermSize的值越大，那么留给线程栈可用的空间就越小，在-Xss参数配置的栈容量不变的情况下，可以创建的线程数也就越小。因此如果是因为这种情况导致的unable to create native thread,那么要么我们增大进程所占用的总内存，或者减少-Xmx或者-Xss来达到创建更多线程的目的。

其中，-Xmx用来设置你的应用程序(不是JVM)能够使用的最大内存数，如果你的程序要花很大内存的话，那就需要修改缺省的设置，比如配置tomcat的时候，如果流量啊程序啊都很大的话就需要加大这个值了，BUT不要大得超过你的机器的内存。

另一个-Xms用来设置程序初始化的时候内存栈的大小，增加这个值的话你的程序的启动性能会得到提高。不过同样有前面的限制，以及受到-Xmx的限制。

总结：  
栈内存溢出: 程序所要求的栈深度过大。  
堆内存溢出： 分清内存泄露还是 内存容量不足。泄露则看对象如何被 GC Root 引用，不足则通过调大-Xms，-Xmx参数。  
直接内存溢出: 系统哪些地方会使用直接内存。

> 参考:[https://blog.csdn.net/weter\_drop/article/details/89395462][https_blog.csdn.net_weter_drop_article_details_89395462]

[https_blog.csdn.net_weter_drop_article_details_89395462]: https://blog.csdn.net/weter_drop/article/details/89395462