JVMの内存泄漏&内存溢出案例分析

西岭千秋雪_2024-06-02 8:33

1、内存溢出

内存溢出指的是程序在申请内存时，没有足够的内存可供分配，导致无法满足程序的内存需求，常见的内存溢出情况包括堆内存溢出（Heap Overflow）和栈溢出（Stack Overflow）：

  • 堆内存溢出通常发生在程序申请的对象过多，堆内存无法满足这些对象的存储需求时。
  • 栈溢出则通常发生在方法调用层次过深，导致栈空间耗尽。（例如递归没有正确设置退出条件）

2、内存泄漏

内存泄漏指的是程序在使用完内存后未能正确释放（回收）这些内存，导致程序长时间运行后占用的内存逐渐增加，最终耗尽系统的可用内存，内存泄漏通常是由于程序中存在未释放的无用对象或资源（如文件句柄、数据库连接等）引起的。

简单的说，就是正常情况下，某个对象不再被程序使用的同时，理应不存在GC Root的引用链上，在下一次GC时被回收，而造成内存泄漏的情况下，即使某个对象不再被程序使用，依旧存在于GC Root的引用链上，导致一直无法被回收，最终会导致内存溢出。

3、监控内存

监控内存的方式有很多种，这里介绍一种使用JDK 1.8自带的VisualVM工具（JDK 1.8之后需要自行下载）：

位于JDK的bin目录下：

也可以通过IDEA集成VisualVM插件的方式：

插件安装完毕后需要进行设置，路径为JDK下的bin目录中的文件。

在启动程序时选择：

会自动弹出Visual界面，进行监控：

使用案例：

这里有一段程序：

public class Demo0 {
    public static long count = 0;
    public static void main(String[] args) throws InterruptedException {
        while (true){
            byte[] bytes = new byte[1024 * 1024 * 5];
        }
    }
}

byte[]数组虽然是强引用，但是作用域只是在每次循环中，一旦循环结束，它们就会超出作用域而无法再被访问到，所以不会发生内存溢出，对应的内存图如下：

接下来改写一下这个程序：

public class Demo0 {
    public static long count = 0;
    public static void main(String[] args) throws InterruptedException {
        List<byte[]> byteList = new ArrayList<>();
        while (true){
            byte[] bytes = new byte[1024 * 1024 * 5];
            byteList.add(bytes);
        }
    }
}

不同于上一个案例。在循环外创建了一个集合，每次都将循环中的bytes的引用放入集合中，最终集合无法被垃圾回收，导致内存溢出：

通过上面两种情况，可以发现，在正常情况下，内存曲线应该是在一个固定的范围内起伏的，而内存溢出的情况则是曲线持续增长，即使手动进行GC也无法回收大部分的对象。

4、内存溢出原因分析

在实际应用中，造成内存溢出的原因一般会有两种，第一种是因为代码中的不规范做法/bug，第二种则是因为某个接口同一时间的并发请求过多，而处理速度慢造成的。

代码中的内存溢出：

4.1、未正确重写hashCode()和equals()方法

我现在有一个Student类：

public class Student {
    private String name;
    private Integer id;
    private byte[] bytes = new byte[1024 * 1024];

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }
}

在主类中通过一个静态HashMap在一个死循环中存放Student对象（关于静态问题后面会分析）：

public class Demo2 {
    public static long count = 0;
    public static Map<Student,Long> map = new HashMap<>();
    public static void main(String[] args) throws InterruptedException {
        while (true){
            if(count++ % 100 == 0){
                Thread.sleep(10);
            }
            Student student = new Student();
            student.setId(1);
            student.setName("张三");
            map.put(student,1L);
        }
    }
}

结果是发生了内存溢出。

要了解为什么上面的做法会导致内存溢出，我们首先复习一下一个元素是如何放入HashMap的，当向 HashMap 中放入一个元素时，会经历以下过程：

  • HashMap 会调用键的hashCode()方法来计算键的哈希值。哈希值是用来确定键值对在哈希表中存储位置的重要依据。
  • HashMap 会根据计算得到的哈希值和哈希表的大小，确定键值对在哈希表中的存储位置。（通过取模运算记录桶下标）
  • 如果存在hash冲突就会进行处理（链表+红黑树），HashMap 将键值对插入到确定的存储位置中，如果存在相同键（根据equals()方法判断），则会更新对应的值。

由此可见，hashCode()和equals()方法在上面的过程中至关重要。如果我们没有重写hashCode()和equals()方法，默认会使用Object类中的，我们可以点进去看一下：

Object中的hashCode() 方法使用的是本地方法，equals()方法使用的是==，比较的是地址值。

在上面的案例中，使用了Object中的hashCode() 和equals() 方法，可能会导致相同ID的对象，计算出的hash值却不一样，就会放在hashMap不同的槽位上。而equals() 方法比较的是地址值：

 Student student = new Student();

每一个创建出的对象的地址值都是不一样的，导致即使学生的id和name相同，也是不同的对象，导致hashMap中存在的无法被回收的对象持续增加，最终OOM

而我们想要的效果是，后一个相同的key覆盖前一个相同的key。就需要重写hashCode() 和equals() 方法：

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }

        if (o == null || getClass() != o.getClass()) {
            return false;
        }

        Student student = (Student) o;

        return new EqualsBuilder().append(id, student.id).isEquals();
    }

    @Override
    public int hashCode() {
        return new HashCodeBuilder(17, 37).append(id).toHashCode();
    }

所以在定义Java Bean时，需要手动重写hashCode() 和equals() 方法 ，并且在定义HashMap时，不建议使用对象作为Key的类型，推荐使用String类型，提高查找效率。

4.2、内部类引用外部类

首先来简单复习一下什么是外部类和内部类：

  • OuterClass是一个外部类，外部类可以直接访问其内部定义的成员变量和方法，但无法直接访问内部类的成员。

  • InnerClass是一个内部类，内部类可以访问外部类的所有成员，包括私有成员，并且可以直接访问外部类的方法和字段。

    public class OuterClass {
    private int outerVar;

      public void outerMethod() {
      // 可以访问内部类
  }

  // 内部类的定义
  public class InnerClass {
      public void innerMethod() {
          // 可以访问外部类的成员变量和方法
          outerVar = 10;
          outerMethod();
      }
  }

    }

在创建内部类的实例时，需要用到外部类的实例 。

 public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        OuterClass.InnerClass inner = outer.new InnerClass();  // 创建内部类的实例需要使用外部类的实例
        inner.innerMethod();  // 调用内部类的方法
    }

一个内部类引用外部类导致内存溢出的案例：

public class Outer {
    private byte[] bytes = new byte[1024 * 1024]; //外部类持有数据

    private String name = "测试";

    class Inner {
        private String name;

        public Inner() {
            this.name = Outer.this.name;
        }
    }

    public static void main(String[] args) throws IOException, InterruptedException {
//        System.in.read();
        int count = 0;
        //集合存放的是Outer外部类中Inner内部类的对象
        ArrayList<Inner> inners = new ArrayList<>();
        while (true) {
            if (count++ % 100 == 0) {
                Thread.sleep(10);
            }
            //创建内部类，需要用到外部类的实例
            inners.add(new Outer().new Inner());
        }
    }
}

我们在inners.add(new Outer().new Inner());这一行打一个断点：

内部类中持有了一个外部类的引用 ，导致外部类此时也在GC Root的引用链上，不会被回收。

如果需要解决这样的问题，我们可以使用静态内部类，再简单的复习一下一般内部类和静态内部类的区别：

  1. 静态内部类可以直接通过外部类访问 ：静态内部类是独立的，不依赖于外部类的实例，因此可以直接通过外部类来访问。（解决内部类引用外部类内存溢出的关键）

  2. 静态内部类不能访问外部类的非静态成员：由于静态内部类是独立的，因此无法访问外部类的非静态成员变量和方法。

  3. 静态内部类可以直接创建实例：可以直接通过"外部类.内部类"的方式创建静态内部类的实例，而不需要先创建外部类的实例。

改造案例中的代码：

public class Outer {
    private byte[] bytes = new byte[1024 * 1024]; //外部类持有数据

    private static String name = "测试";

    static class Inner {
        private String name;

        public Inner() {
            this.name = Outer.name;
        }
    }

    public static void main(String[] args) throws IOException, InterruptedException {
//        System.in.read();
        int count = 0;
        ArrayList<Inner> inners = new ArrayList<>();
        while (true) {
            if (count++ % 100 == 0) {
                Thread.sleep(10);
            }
            inners.add(new Inner());
        }
    }
}

此时内部类完全独立，不再持有外部类的引用，所以外部类可以正常被回收。

4.3、ThreadLocal的不正确使用

如果是在手动创建线程的线程中使用ThreadLocal，一般不会造成内存溢出：

public class Demo5_1 {
    public static ThreadLocal<Object> threadLocal = new ThreadLocal<>();

    public static void main(String[] args) throws InterruptedException {
        while (true) {
            new Thread(() -> {
                threadLocal.set(new byte[1024 * 1024 * 10]);
            }).start();
            Thread.sleep(10);
        }
    }
}

每个线程对ThreadLocal中存储的对象都有独立的副本，线程一旦结束，其中的内存便会得到释放，即使不使用.remove()方法，如果每次存放入ThreadLocal的数据量不大，也不一定会发生内存溢出。

当使用线程池统一创建线程时，线程不一定是立刻被回收，如果没有使用.remove()方法 ，则大概率会造成内存溢出。

public class Demo5 {
    public static ThreadLocal<Object> threadLocal = new ThreadLocal<>();

    public static void main(String[] args) throws InterruptedException {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(Integer.MAX_VALUE, Integer.MAX_VALUE,
                0, TimeUnit.DAYS, new SynchronousQueue<>());
        int count = 0;
        while (true) {
            System.out.println(++count);
            threadPoolExecutor.execute(() -> {
                threadLocal.set(new byte[1024 * 1024]);
            });
            Thread.sleep(10);
        }
    }
}

解决方式也很简单，线程中的逻辑执行完成后，手动调用ThreadLocal的.remove()方法。

4.4、String的Intern()方法

Intern() 方法的作用是，将调用该方法的字符串放入字符串常量池中，在JDK 1.8中，字符串常量池位于堆中。

如果不同字符串的Intern() 方法被大量调用，达到堆内存上限后也会造成内存溢出的问题。（在实际开发中很少遇到，了解即可）

4.5、通过static字段修饰的容器保存对象

在前篇中提到，如果某个类的静态资源被引用，即使该类的实例全部不可达，该类也无法被回收。 并且static 字段属于类级别的，而不是属于某个实例，生命周期和类一样长，因此保存在其中的对象也会持续存在直到类被卸载。

当大量对象被保存在 static 字段所属的类中时，这些对象将随着类的加载而被创建并持续存在于堆内存中。如果这些对象没有被及时释放，就会导致堆内存不断被占用，最终导致内存溢出。

static 字段属于类级别的，所有实例共享同一个 static 字段，因此如果保存在其中的对象过多或者对象占用过多内存，就会对整个应用产生影响，容易导致内存资源的耗尽。

所以被static关键字修饰的变量，当不再使用时，需要手动将引用设置为null方便下次回收。

4.6、IO或数据库连接资源没有及时关闭

IO或数据库连接资源没有及时关闭，并不一定会100%导致内存泄漏，其原因与在手动创建线程中使用完ThreadLocal后没有手动调用.remove()方法类似。如果是在连接池中使用，或者短时间内连接数过多，依旧有可能会造成内存溢出。

推荐使用JDK 7 的新特性try..with...resources进行连接管理。

前提是被管理的连接需要实现AutoCloseable接口。

另一个可能导致内存溢出的原因，在于多线程并发访问时：

4.7、多线程并发访问

通常，用户在页面上点击按钮发送请求，服务器端会通过数据库进行处理，将查询的结果集读取到内存中并且返回给页面，然后就可以释放这部分内存。但是如果处理逻辑复杂，过程消耗时间较久，同时又有大量的请求，会导致数据全部积压在内存中，最终导致内存溢出。

例如下面这一段代码，模拟了数据量大，并且处理时间长的场景：

    @GetMapping("/test")
    public void test1() throws InterruptedException {
        byte[] bytes = new byte[1024 * 1024 * 100];//100m
        Thread.sleep(10 * 1000L);
    }

如果需要演示高并发的场景，可以通过压力测试工具实现，我这里使用Jmeter。

准备工作：将最大堆内存和初始堆内存设置成1g

配置Jmeter

经过了100次/s的请求，发生了内存溢出：

再模拟一种使用静态关键字修饰的容器存放大量数据的情况：

    /**
     * 登录接口 传递名字和id,放入hashmap中
     */
    @PostMapping("/login")
    public void login(String name, Long id) {
        userCache.put(id, new UserEntity(id, name));
    }

Jmeter配置

最终同样会造成内存溢出。

相关推荐
紅色彼岸花3 分钟前
第六章：DNS域名解析服务器
运维·服务器
Spring_java_gg7 分钟前
如何抵御 Linux 服务器黑客威胁和攻击
linux·服务器·网络·安全·web安全
✿ ༺ ོIT技术༻8 分钟前
Linux：认识文件系统
linux·运维·服务器
恒辉信达9 分钟前
hhdb数据库介绍(8-4)
服务器·数据库·mysql
blammmp15 分钟前
Java：数据结构-枚举
java·开发语言·数据结构
暗黑起源喵33 分钟前
设计模式-工厂设计模式
java·开发语言·设计模式
WaaTong38 分钟前
Java反射
java·开发语言·反射
我言秋日胜春朝★38 分钟前
【Linux】冯诺依曼体系、再谈操作系统
linux·运维·服务器
齐 飞1 小时前
MongoDB笔记01-概念与安装
前端·数据库·笔记·后端·mongodb
wowocpp1 小时前
ubuntu 22.04 server 格式化 磁盘 为 ext4 并 自动挂载 LTS
服务器·数据库·ubuntu
热门推荐
01【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总02(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04【AIGC】重塑未来的科技巨轮05全面解析：构建基于深度学习的安全帽检测系统（UI界面+YOLO代码+数据集）06【经验分享】Ubuntu22.04安装微信(linux官方版)07基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测08Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO09RAG 实践- Ollama+RagFlow 部署本地知识库10【TC3xx芯片】TC3xx芯片电源管理系统PMS详解