OOM

灰太狼 2022-12-11 15:06 157阅读 0赞

>  *  [https://yuanyu.blog.csdn.net/article/details/106813541][https_yuanyu.blog.csdn.net_article_details_106813541] 
>  *  [https://yuanyu.blog.csdn.net/article/details/108905601][https_yuanyu.blog.csdn.net_article_details_108905601]

// vi Main.java
    // javac -d . Main.java
    // java cn.yuanyu.jvm.Main
    package cn.yuanyu.jvm;
    public class Main {
        public static void main(String[] args) {
            System.out.println("run..");
        }
    }

--------------------

# java.lang.StackOverflowError #

// jinfo -flag ThreadStackSize 进程号
    public class StackOverflowErrorDemo {
        public static void main(String[] args) throws InterruptedException, IOException {
            //main(args);
            stackOverflowError();
        }
        public static void stackOverflowError(){
            stackOverflowError();
        }
    }

Exception in thread "main" java.lang.StackOverflowError
    	at StackOverflowErrorDemo.stackOverflowError(StackOverflowErrorDemo.java:10)

# java.lang.OutOfMemoryError: Java heap space #

//-Xms10m -Xmx10m
    
    //jps -l
    //jinfo -flags 25052
    public class JavaHeapSpaceDemo {
        public static void main(String[] args) throws InterruptedException {
            byte[] bytes = new byte[80 * 1024 * 1024]; // 80MB
            //String str = "rush";
            //while (true) {
            //    str += str + new Random().nextInt(111111111) + new Random().nextInt(222222222);
            //    str.intern();
            //}
        }
    }

Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
    	at JavaHeapSpaceDemo.main(JavaHeapSpaceDemo.java:7)

# java.lang.OutOfMemoryError: GC overhead limit exceeded #

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNzk0OTcz_size_16_color_FFFFFF_t_70][]

/**
     * -Xms10m -Xmx10m -XX:+PrintGCDetails -XX:MaxDirectMemorySize=5m
     *
     * GC回收时间过长时会抛出OutOfMemoryError。
     * 过长的定义是，超过98%的时间用来做GC并且回收了不到2%的堆内存，连续多次 GC 都只回收了不到2%的极端情况下才会抛出。
     * 假如不抛出 GC overhead limit 错误会发生什么情况呢?
     * 那就是GC清理的这么点内存很快会再次填满，迫使GC再次执行．这样就形成恶性循环，CPU续用率一直是100%，而GC却没有任何成果
     */
    public class GCOverheadLimitExceededDemo {
        public static void main(String[] args) throws InterruptedException {
            int i = 0;
            List<String> list = new ArrayList<>();
            try {
                while (true) {
                    list.add(String.valueOf(++i).intern());
                }
            } catch (Throwable e) {
                System.out.println("i=" + i);
                e.printStackTrace();
                throw e;
            } finally {
                System.out.println("size=" + list.size());
            }
        }
    }

\[Full GC (Ergonomics) \[PSYoungGen: 2047K->2047K(2560K)\] \[ParOldGen: 7082K->7082K(7168K)\] 9130K->9130K(9728K), \[Metaspace: 3476K->3476K(1056768K)\], 0.0311779 secs\] \[Times: user=0.11 sys=0.00, real=0.03 secs\]

Exception in thread "main" java.lang.OutOfMemoryError: GC overhead limit exceeded
    	at java.lang.AbstractStringBuilder.<init>(AbstractStringBuilder.java:68)
    	at java.lang.StringBuilder.<init>(StringBuilder.java:89)
    	at java.lang.StackTraceElement.toString(StackTraceElement.java:172)
    	at java.lang.String.valueOf(String.java:2994)
    	at java.lang.StringBuilder.append(StringBuilder.java:131)
    	at java.lang.Throwable.printStackTrace(Throwable.java:658)
    	at java.lang.Throwable.printStackTrace(Throwable.java:643)
    	at java.lang.Throwable.printStackTrace(Throwable.java:634)
    	at GCOverheadLimitExceededDemo.main(GCOverheadLimitExceededDemo.java:22)

# java.lang.OutOfMemoryError: Direct buffer memory #

/**
     * -Xms10m -Xmx10m -XX:+PrintGCDetails -XX:MaxDirectMemorySize=5m
     *
     * 故障现象: java.lang.OutOfHemoryError: Direct buffer memory
     *
     * 导致原因:
     * 写NIO程序经常使用ByteBuffer来读取或者写入数据，这是一种基于通道(Channel)与缓冲区(Buffer)的I/O方式，
     * 它可以使用Native函数库直接分配堆外内存，然后通过一个存储在Java堆里面的DirectByteBuffer对象作为这块内存的引用进行操作。
     * 这样能在一些场景中显著提高性能，因为避免了在Java堆和Native堆中来回复制数据。
     *
     * ByteBuffer.allocate(capability)第一种方式是分配JVM堆内存，属于GC管辖范围，由于需要拷贝所以速度相对较慢
     * ByteBuffer.allocteDirect(capability)第二种方式是分配OS（操作系统）本地内存，不属于GC管辖范围，由于不需要内存拷贝所以速度相对较快。
     *
     * 但如果不断分配本地内存，堆内存很少使用，那么JVM就不需要执行GC，DirectByteBuffer对象们就不会被回收，
     * 这时候堆内存充足，但本地内存可能已经使用光了，再次尝试分配本地内存就会出现OutOfMemoryError，那程序就直接崩溃了。
     */
    public class DirectBufferMemoryDemo {
        public static void main(String[] args) throws InterruptedException {
            System.out.println("配置的maxDirectMemory=" + (VM.maxDirectMemory() / (double) 1024 / 1024) + "MB"); // 本地内存的 1/4
            TimeUnit.MILLISECONDS.sleep(3000);
            ByteBuffer bb = ByteBuffer.allocateDirect(6 * 1024 * 1024);
        }
    }

Exception in thread "main" java.lang.OutOfMemoryError: Direct buffer memory
    	at java.nio.Bits.reserveMemory(Bits.java:694)
    	at java.nio.DirectByteBuffer.<init>(DirectByteBuffer.java:123)
    	at java.nio.ByteBuffer.allocateDirect(ByteBuffer.java:311)
    	at DirectBufferMemoryDemo.main(DirectBufferMemoryDemo.java:26)

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNzk0OTcz_size_16_color_FFFFFF_t_70 1][]

>  *  [https://www.zhihu.com/question/399007267/answer/1260691185][https_www.zhihu.com_question_399007267_answer_1260691185]
>  *  [https://blog.csdn.net/cloud\_ll/article/details/50815671][https_blog.csdn.net_cloud_ll_article_details_50815671]
>  *  [https://blog.csdn.net/qq\_21125183/article/details/88701156][https_blog.csdn.net_qq_21125183_article_details_88701156]

# java.lang.OutOfMemoryError: unable to create new native thread #

### centos7 
    ### 创建用户
    useradd -m tt
    ### 设置密码
    passwd tt
    ### 切换用户
    su tt
    su root
    ### 查看用户最多可开启的程序数目（root和普通用于切换看看效果）
    ulimit -u
    ### 修改默认限制（没用这个文件就添加）
    vi /etc/security/limits.d/90-nproc.conf
    ### 重启
    reboot

### vi /etc/security/limits.d/90-nproc.conf 
    tt      soft    nproc   50
    root    soft    nproc   unlimited
    *       soft    nproc   1024

/**
     * 高并发请求服务器时，经常出现如下异常: java.lang.OutOfMemoryError: unable to create new native thread
     * 准确的讲该native thread异常与对应的平台有关
     *
     * 导致原因:
     * 1、你的应用创建了太多线程了，一个应用进程创建多个线程，超过系统承载极限。
     * 2、你的服务器并不允许你的应用程序创建这么多线程，Linux系统默认允许单个进程可以创建的线程数是1024个，你的应用创建超过这个数量，就会报java.lang.OutOfMemoryError: unable to create new native thread
     * 解决办法:
     * 1、想办法降低你应用程序创建线程的数量，分析应用是否真的需要创建这么多线程，如果不是，改代码将线程数降到最低
     * 2、对于有的应用，确实需要创建很多线程，远超过Linux系统的默认1024个线程的限制，可以通过修改Linux服务器配置，扩大linux默认限制
     */
    // vi UnableCreateNewThreadDemo.java
    // javac UnableCreateNewThreadDemo.java
    // java UnableCreateNewThreadDemo
    public class UnableCreateNewThreadDemo {
        public static void main(String[] args) {
            Runnable task = () -> {
                System.out.println(Thread.currentThread().getName() + " run.");
                try {
                    Thread.sleep(Integer.MAX_VALUE);
                } catch (InterruptedException ignored) {
                }
            };
            for (int i = 0; ; i++) {
                new Thread(task, String.valueOf(i)).start();
            }
        }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNzk0OTcz_size_16_color_FFFFFF_t_70 2][]

>  [https://blog.csdn.net/u013282159/article/details/81110992][https_blog.csdn.net_u013282159_article_details_81110992]

# java.lang.OutOfMemoryError: Metaspace #

![20201003140646456.png][]

/**
     * JVM参数
     * -XX:MetaspaceSize=8m -XX:MaxMetaspaceSize=8m
     *
     * java8及之后的版本使用Metaspace来替代永久代。
     *
     * Metaspace是方法区在HotSpot中的实现，它与永久代最大的区别在于，Metaspace并不在虚拟机内存中而是使用本地内存
     * 也即在java8中，classe metadata(the virtual machines internal presentation of Java class)，被存储在叫做Metaspace的native memory
     *
     * 永久代（java8后被原空问Metaspace取代了）存放了以下信息:
     * 1、虚拟机加载的类信息
     * 2、常量池
     * 3、静态变量
     * 4、即时时编译后的代码
     *
     * 模拟Metaspace空问溢出，我们不断生成类往元空间灌，类占据的空间总是会超过Metaspace指定的空间大小的
     */
    //<dependency>
    //    <groupId>cglib</groupId>
    //    <artifactId>cglib</artifactId>
    //    <version>3.3.0</version>
    //</dependency>
    public class MetaspaceOOMTest {
        static class OOMTest {}
        public static void main(String[] args) {
            int i = 0; // 模拟计算多少次以后发送异常
            try {
                while (true) {
                    i++;
                    Enhancer enhancer = new Enhancer();
                    enhancer.setSuperclass(OOMTest.class);
                    enhancer.setUseCache(false);
                    enhancer.setCallback(new MethodInterceptor() {
                        @Override
                        public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                            return methodProxy.invokeSuper(o, args);
                        }
                    });
                    // 创建对象
                    Object oomTest = (OOMTest)enhancer.create();
                }
            } catch (Throwable e) {
                System.out.println("i=" + i);
                e.printStackTrace();
            }
        }
    }

i=282
    net.sf.cglib.core.CodeGenerationException: java.lang.reflect.InvocationTargetException-->null
    	at net.sf.cglib.core.AbstractClassGenerator.generate(AbstractClassGenerator.java:348)
    	at net.sf.cglib.proxy.Enhancer.generate(Enhancer.java:492)
    	at net.sf.cglib.core.AbstractClassGenerator$ClassLoaderData.get(AbstractClassGenerator.java:117)
    	at net.sf.cglib.core.AbstractClassGenerator.create(AbstractClassGenerator.java:294)
    	at net.sf.cglib.proxy.Enhancer.createHelper(Enhancer.java:480)
    	at net.sf.cglib.proxy.Enhancer.create(Enhancer.java:305)
    	at MetaspaceOOMTest.main(MetaspaceOOMTest.java:46)
    Caused by: java.lang.reflect.InvocationTargetException
    	at sun.reflect.GeneratedMethodAccessor1.invoke(Unknown Source)
    	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    	at java.lang.reflect.Method.invoke(Method.java:498)
    	at net.sf.cglib.core.ReflectUtils.defineClass(ReflectUtils.java:459)
    	at net.sf.cglib.core.AbstractClassGenerator.generate(AbstractClassGenerator.java:339)
    	... 6 more
    Caused by: java.lang.OutOfMemoryError: Metaspace
    	at java.lang.ClassLoader.defineClass1(Native Method)
    	at java.lang.ClassLoader.defineClass(ClassLoader.java:763)
    	... 11 more

[https_yuanyu.blog.csdn.net_article_details_106813541]: https://yuanyu.blog.csdn.net/article/details/106813541
[https_yuanyu.blog.csdn.net_article_details_108905601]: https://yuanyu.blog.csdn.net/article/details/108905601
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNzk0OTcz_size_16_color_FFFFFF_t_70]: /images/20221123/ac2abe6b678740b087b3bd6bca191e89.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNzk0OTcz_size_16_color_FFFFFF_t_70 1]: /images/20221123/613658b362ea451babac2b1d21099a5d.png
[https_www.zhihu.com_question_399007267_answer_1260691185]: https://www.zhihu.com/question/399007267/answer/1260691185
[https_blog.csdn.net_cloud_ll_article_details_50815671]: https://blog.csdn.net/cloud_ll/article/details/50815671
[https_blog.csdn.net_qq_21125183_article_details_88701156]: https://blog.csdn.net/qq_21125183/article/details/88701156
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNzk0OTcz_size_16_color_FFFFFF_t_70 2]: /images/20221123/3f6060a6d0764dc09fa5bb0b663a2a8f.png
[https_blog.csdn.net_u013282159_article_details_81110992]: https://blog.csdn.net/u013282159/article/details/81110992
[20201003140646456.png]: /images/20221123/08f01c9ea6cb4161b533898a9da67c3a.png