zoukankan      html  css  js  c++  java
  • Java内存溢出OOM

    Java内存溢出OOM

    经典错误

    JVM中常见的两个错误

    StackoverFlowError :栈溢出

    OutofMemoryError: java heap space:堆溢出

    除此之外,还有以下的错误

    • java.lang.StackOverflowError
    • java.lang.OutOfMemoryError:java heap space
    • java.lang.OutOfMemoryError:GC overhead limit exceeeded
    • java.lang.OutOfMemoryError:Direct buffer memory
    • java.lang.OutOfMemoryError:unable to create new native thread
    • java.lang.OutOfMemoryError:Metaspace

    架构

    OutOfMemoryError和StackOverflowError是属于Error,不是Exception

    StackoverFlowError

    堆栈溢出,我们有最简单的一个递归调用,就会造成堆栈溢出,也就是深度的方法调用

    栈一般是512K,不断的深度调用,直到栈被撑破

    public class StackOverflowErrorDemo {
    
        public static void main(String[] args) {
            stackOverflowError();
        }
        /**
         * 栈一般是512K,不断的深度调用,直到栈被撑破
         * Exception in thread "main" java.lang.StackOverflowError
         */
        private static void stackOverflowError() {
            stackOverflowError();
        }
    }
    

    运行结果

    Exception in thread "main" java.lang.StackOverflowError
        at com.moxi.interview.study.oom.StackOverflowErrorDemo.stackOverflowError(StackOverflowErrorDemo.java:17)
    

    OutOfMemoryError

    java heap space

    创建了很多对象,导致堆空间不够存储

    /**
     * Java堆内存不足
     */
    public class JavaHeapSpaceDemo {
        public static void main(String[] args) {
    
            // 堆空间的大小 -Xms10m -Xmx10m
            // 创建一个 80M的字节数组
            byte [] bytes = new byte[80 * 1024 * 1024];
        }
    }
    

    我们创建一个80M的数组,会直接出现Java heap space

    Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
    

    GC overhead limit exceeded

    GC回收时间过长时会抛出OutOfMemoryError,过长的定义是,超过了98%的时间用来做GC,并且回收了不到2%的堆内存

    连续多次GC都只回收了不到2%的极端情况下,才会抛出。假设不抛出GC overhead limit 错误会造成什么情况呢?

    那就是GC清理的这点内存很快会再次被填满,迫使GC再次执行,这样就形成了恶性循环,CPU的使用率一直都是100%,而GC却没有任何成果。

    代码演示:

    为了更快的达到效果,我们首先需要设置JVM启动参数

    -Xms10m -Xmx10m -XX:+PrintGCDetails -XX:MaxDirectMemorySize=5m
    

    这个异常出现的步骤就是,我们不断的像list中插入String对象,直到启动GC回收

    /**
     * GC 回收超时
     * JVM参数配置: -Xms10m -Xmx10m -XX:+PrintGCDetails
     */
    public class GCOverheadLimitDemo {
        public static void main(String[] args) {
            int i = 0;
            List<String> list = new ArrayList<>();
            try {
                while(true) {
                    //1.6时intern()方法发现字符串常量池(存储永久代)没有就复制,物理拷贝
                    //1.7时intern()方法发现字符串常量池(存储堆)没有就在保存地址值映射实际堆内存对象
                    list.add(String.valueOf(++i).intern());
                }
            } catch (Exception e) {
                System.out.println("***************i:" + i);
                e.printStackTrace();
                throw e;
            } finally {
    
            }
    
        }
    }
    

    运行结果

    [Full GC (Ergonomics) [PSYoungGen: 2047K->2047K(2560K)] [ParOldGen: 7106K->7106K(7168K)] 9154K->9154K(9728K), [Metaspace: 3504K->3504K(1056768K)], 0.0311093 secs] [Times: user=0.13 sys=0.00, real=0.03 secs] 
    [Full GC (Ergonomics) [PSYoungGen: 2047K->0K(2560K)] [ParOldGen: 7136K->667K(7168K)] 9184K->667K(9728K), [Metaspace: 3540K->3540K(1056768K)], 0.0058093 secs] [Times: user=0.00 sys=0.00, real=0.01 secs] 
    Heap
     PSYoungGen      total 2560K, used 114K [0x00000000ffd00000, 0x0000000100000000, 0x0000000100000000)
      eden space 2048K, 5% used [0x00000000ffd00000,0x00000000ffd1c878,0x00000000fff00000)
      from space 512K, 0% used [0x00000000fff80000,0x00000000fff80000,0x0000000100000000)
      to   space 512K, 0% used [0x00000000fff00000,0x00000000fff00000,0x00000000fff80000)
     ParOldGen       total 7168K, used 667K [0x00000000ff600000, 0x00000000ffd00000, 0x00000000ffd00000)
      object space 7168K, 9% used [0x00000000ff600000,0x00000000ff6a6ff8,0x00000000ffd00000)
     Metaspace       used 3605K, capacity 4540K, committed 4864K, reserved 1056768K
      class space    used 399K, capacity 428K, committed 512K, reserved 1048576K
    
    
    Exception in thread "main" java.lang.OutOfMemoryError: GC overhead limit exceeded
        at java.lang.Integer.toString(Integer.java:403)
        at java.lang.String.valueOf(String.java:3099)
        at com.moxi.interview.study.oom.GCOverheadLimitDemo.main(GCOverheadLimitDemo.java:18)
    

    我们能够看到 多次Full GC,并没有清理出空间,在多次执行GC操作后,就抛出异常 GC overhead limit

    Direct buffer memory

    Netty + NIO:这是由于NIO引起的

    写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,那么程序就崩溃了。

    一句话说:本地内存不足,但是堆内存充足的时候,就会出现这个问题

    我们使用 -XX:MaxDirectMemorySize=5m 配置能使用的堆外物理内存为5M

    -Xms20m -Xmx20m -XX:+PrintGCDetails -XX:MaxDirectMemorySize=5m
    

    然后我们申请一个6M的空间

    // 只设置了5M的物理内存使用,但是却分配 6M的空间
    ByteBuffer bb = ByteBuffer.allocateDirect(6 * 1024 * 1024);
    

    这个时候,运行就会出现问题了

    配置的maxDirectMemory:5.0MB
    [GC (System.gc()) [PSYoungGen: 2030K->488K(2560K)] 2030K->796K(9728K), 0.0008326 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
    [Full GC (System.gc()) [PSYoungGen: 488K->0K(2560K)] [ParOldGen: 308K->712K(7168K)] 796K->712K(9728K), [Metaspace: 3512K->3512K(1056768K)], 0.0052052 secs] [Times: user=0.09 sys=0.00, real=0.00 secs] 
    Exception in thread "main" java.lang.OutOfMemoryError: Direct buffer memory
        at java.nio.Bits.reserveMemory(Bits.java:693)
        at java.nio.DirectByteBuffer.<init>(DirectByteBuffer.java:123)
        at java.nio.ByteBuffer.allocateDirect(ByteBuffer.java:311)
        at com.moxi.interview.study.oom.DIrectBufferMemoryDemo.main(DIrectBufferMemoryDemo.java:19)
    

    unable to create new native thread

    不能够创建更多的新的线程了,也就是说创建线程的上限达到了

    在高并发场景的时候,会应用到

    高并发请求服务器时,经常会出现如下异常java.lang.OutOfMemoryError:unable to create new native thread,准确说该native thread异常与对应的平台有关

    导致原因:

    • 应用创建了太多线程,一个应用进程创建多个线程,超过系统承载极限
    • 服务器并不允许你的应用程序创建这么多线程,linux系统默认运行单个进程可以创建的线程为1024个,如果应用创建超过这个数量,就会报 java.lang.OutOfMemoryError:unable to create new native thread

    解决方法:

    1. 想办法降低你应用程序创建线程的数量,分析应用是否真的需要创建这么多线程,如果不是,改代码将线程数降到最低
    2. 对于有的应用,确实需要创建很多线程,远超过linux系统默认1024个线程限制,可以通过修改linux服务器配置,扩大linux默认限制
    /**
     * 无法创建更多的线程
     */
    public class UnableCreateNewThreadDemo {
        public static void main(String[] args) {
            for (int i = 0; ; i++) {
                System.out.println("************** i = " + i);
                new Thread(() -> {
                    try {
                        TimeUnit.SECONDS.sleep(Integer.MAX_VALUE);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }, String.valueOf(i)).start();
            }
        }
    }
    

    这个时候,就会出现下列的错误,线程数大概在 900多个

    Exception in thread "main" java.lang.OutOfMemoryError: unable to cerate new native thread
    

    如何查看线程数

    ulimit -u
    

    Metaspace

    元空间内存不足,Matespace元空间应用的是本地内存

    -XX:MetaspaceSize 的初始化大小为20M

    元空间是什么

    元空间就是我们的方法区,存放的是类模板,类信息,常量池等

    Metaspace是方法区HotSpot中的实现,它与持久代最大的区别在于:Metaspace并不在虚拟内存中,而是使用本地内存,也即在java8中,class metadata(the virtual machines internal presentation of Java class),被存储在叫做Matespace的native memory

    永久代(java8后背元空间Metaspace取代了)存放了以下信息:

    • 虚拟机加载的类信息
    • 常量池
    • 静态变量
    • 即时编译后的代码

    模拟Metaspace空间溢出,我们不断生成类 往元空间里灌输,类占据的空间总会超过Metaspace指定的空间大小

    代码

    在模拟异常生成时候,因为初始化的元空间为20M,因此我们使用JVM参数调整元空间的大小,为了更好的效果

    -XX:MetaspaceSize=8m -XX:MaxMetaspaceSize=8m
    

    代码如下:

    /**
     * 元空间溢出
     *
     */
    public class MetaspaceOutOfMemoryDemo {
    
        // 静态类
        static class OOMTest {
    
        }
    
        public static void main(final String[] args) {
            // 模拟计数多少次以后发生异常
            int i =0;
            try {
                while (true) {
                    i++;
                    // 使用Spring的动态字节码技术
                    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);
                        }
                    });
                }
            } catch (Exception e) {
                System.out.println("发生异常的次数:" + i);
                e.printStackTrace();
            } finally {
    
            }
    
        }
    }
    

    会出现以下错误:

    发生异常的次数: 201
    java.lang.OutOfMemoryError:Metaspace
    

    注意

    在JDK1.7之前:永久代是方法区的实现,存放了运行时常量池、字符串常量池和静态变量等。

    在JDK1.7:永久代是方法区的实现,将字符串常量池和静态变量等移出至堆内存。运行时常量池等剩下的还再永久代(方法区)

    在JDK1.8及以后:永久代被元空间替代,相当于元空间实现方法区,此时字符串常量池和静态变量还在堆,运行时常量池还在方法区(元空间),元空间使用的是直接内存。

    -XX:MetaspaceSize=N//设置Metaspace的初始(和最小大小) -XX:MaxMetaspaceSize=N//设置Metaspace的最大大小 与永久代很大的不同就是,如果不指定大小的话,随着更多类的创建,虚拟机会耗尽所有可用的系统内存。

  • 相关阅读:
    Maven关于web.xml中Servlet和Servlet映射的问题
    intellij idea的Maven项目运行报程序包找不到的错误
    修改Maven项目默认JDK版本
    刷题15. 3Sum
    刷题11. Container With Most Water
    刷题10. Regular Expression Matching
    刷题5. Longest Palindromic Substring
    刷题4. Median of Two Sorted Arrays
    刷题3. Longest Substring Without Repeating Characters
    刷题2. Add Two Numbers
  • 原文地址:https://www.cnblogs.com/bbgs-xc/p/12874232.html
Copyright © 2011-2022 走看看