内存泄漏详解

_whitepure2024-07-26 15:01

文章目录

什么是内存泄漏

内存泄漏是指不使用的对象持续占有内存使得内存得不到释放，从而造成内存空间的浪费。严格来说，只有对象不会再被程序用到了，但是GC又不能回收他们的情况，才叫内存泄漏。但实际情况很多时候一些不太好的实践会导致对象的生命周期变得很长，甚至导致00M，也可以叫做宽泛意义上的"内存泄漏"。

举个例子，创建的连接不再使用时，需要调用close方法关闭连接，只有连接被关闭后，GC才会回收对应的对象。忘记关闭这些资源会导致持续占有内存，无法被GC回收。这样就会导致内存泄露，最终导致内存溢出。

java 复制代码 
public class MemoryLeak {
    public static void main(String[] args) {
      try{
          Connection conn =null;
          Class.forName("com.mysql.jdbc.Driver");
          conn =DriverManager.getConnection("url","","");
          Statement stmt =conn.createStatement();
          ResultSet rs =stmt.executeQuery("....");
      } catch(Exception e){//异常日志
      } finally {
        // 1．关闭结果集 Statement
        // 2．关闭声明的对象 ResultSet
        // 3．关闭连接 Connection
    }
  }
}

内存泄漏最明显的问题是频繁GC，从而STW次数增加，导致用户体验变差。如果内存泄露问题严重，会导致OOM，直接导致程序不能正常运行。尽管内存泄漏并不会立刻引起程序崩溃，但是一旦发生内存泄漏，程序中的可用内存就会被逐步蚕食，直至耗尽所有内存，最终出现OutOfMemory异常，导致程序崩溃。

内存泄漏的原因

Java使用可达性分析算法来标记垃圾对象。在这个过程中，算法会标记那些仍然可以从根对象（如栈、静态变量等）直接访问到的对象为"可达"，而那些无法从根对象访问到的对象则标记为"不可达"。不可达的对象是候选垃圾，可以被回收。有时候即使某些对象不再使用，它们的引用链可能仍然存在，导致这些对象没有被标记为不可达，从而造成内存泄漏。在这种情况下，虽然这些对象已经不再被实际使用，但由于引用链未断开，它们仍然占用内存。

大多数内存泄露的原因是，长生命周期的对象引用了短生命周期的对象。例如，A对象引用B对象，A对象的生命周期（t1-t4）比B对象的生命周期（t2-t3）长的多。当B对象没有被应用程序使用之后，A对象仍然在引用着B对象。这样，垃圾回收器就没办法将B对象从内存中移除，从而导致内存泄露问题。

所以减少长生命周期对象持有短生命周期对象的强引用是解决内存泄漏的一个关键点。利用弱引用或者软引用可以让垃圾回收器更容易回收不再需要的对象。对于外部资源，如数据库连接、文件、网络连接，用完后应该及时关闭。try-with-resources语句是管理这些资源的有效工具，同时移除不再需要的事件监听器也能防止内存泄漏。管理集合时，设定大小限制并定期清理过期数据可以避免无限增长。使用有界数据结构能帮助控制缓存的大小。静态集合要特别留意，避免它们占用过多内存，通过定期清理来管理数据的存储。通过这些措施，可以减少内存泄漏的风险。

排查及解决内存泄漏

根据运维之前收集到的内存数据、GC日志尝试判断哪里出现了问题。结果发现老年代的内存使用就算是发生GC也一直居高不下，而且随着时间推移也越来越高。

使用jstat -gc <vmid> 查看GC垃圾回收统计信息，看Full GC后堆空间使用内存还持续增长，且有增长到Xmx设定值的趋势，基本可以肯定存在内存泄露。如果当前完全垃圾回收后内存增长到一个值之后，又能回落，总体上处于一个动态平衡，那么内存泄漏基本可以排除；也可以隔断时间抽取老年代占用内存情况，如果老年代占用情况持续上升也很有可能存在内存泄露的情况。

内存泄漏的主要表象就是内存不足，所以首先要看一下JVM启动参数中内存空间分配是否过小，如果是这种问题调整该参数即可。如果不是参数调的太小，那么应该确定是否新部署或有新变更。首先需要确认是否在最近进行了新的部署或有其他相关的变更，例如代码更新、配置修改等。这些变更可能导致应用出现性能问题，特别是在高负载情况下。

遇到内存泄漏问题，最经典的就是用MAT工具分析dump文件然后找到具体的代码。但如果dump文件巨大就不建议这样，可以使用其他方案，例如，重启、本地复现、jmap -histo:live <pid>在线进行分析等其他方案解决。使用MAT定位内存泄漏思路：

  1. 打开MAT中histogram，找到堆内存中占用最大的对象，内存泄漏很有可能就是由大对象导致的；

  2. 由大对象找被哪些线程引用，查看内存占用最大的线程；

  3. 从线程中的堆栈信息找到项目中自定义的包和对象，从而可定位到具体的代码；

避免内存泄漏

内存泄漏是由代码中的问题导致的，这些问题通常源于编程错误、设计不良或对资源管理的忽视。那想要避免内存泄漏，就需要从代码层面入手。

及时释放资源

如数据库连接、网络连接和IO连接等，当不再使用时，需要调用close方法来释放连接。只有连接被关闭后，垃圾回收器才会回收对应的对象。否则如果在连接过程中，对一些对象不显性地关闭，将会造成大量的对象无法被回收，从而引起内存泄漏。

在这个例子中，数据库连接conn在方法结束时没有被关闭。这导致了连接资源的泄漏，因为即使在出现异常时也没有释放连接，可能会导致数据库连接池资源被耗尽，影响系统的正常运行。

java 复制代码 
public class ResourceLeakExample {
    public void process() {
        Connection conn = null;
        try {
            conn = DriverManager.getConnection(url, user, password);
            // 使用连接
        } catch (SQLException e) {
            e.printStackTrace();
        }
        // 连接没有关闭，导致资源泄漏
    }
}

这里使用了try-with-resources语句来解决这个问题，这种方式可以自动管理资源的释放。连接conn会在try块结束时被自动关闭，即使发生了异常也不会有资源泄漏的问题。

java 复制代码 
public class ResourceLeakFixedExample {
    public void process() {
        try (Connection conn = DriverManager.getConnection(url, user, password)) {
            // 使用连接
        } catch (SQLException e) {
            e.printStackTrace();
        }
        // 连接自动关闭
    }
}

设置合理的变量作用域

一个变量的定义的作用范围大于其使用范围，很有可能会造成内存泄漏。静态变量cache持有所有添加对象的引用。由于这个集合是静态的，它会持续存在，导致对象不会被垃圾回收，可能导致内存使用逐渐增大，最终可能耗尽内存。

java 复制代码 
public class StaticCacheExample {
    private static List<Object> cache = new ArrayList<>();

    public static void addToCache(Object obj) {
        cache.add(obj); // 对象添加到静态列表
    }
}

可以将其作用域缩小，解决这个问题。在这个例子中，localCache是一个局部变量，存在于方法的作用域内。当方法执行完毕后，localCache变量会被垃圾回收器回收。通过调用clear方法清空缓存，可以进一步减少内存占用。

java 复制代码 
public class LocalCacheExample {
    public void process() {
        List<Object> localCache = new ArrayList<>();
        localCache.add(new Object());
        // 使用 localCache
        localCache.clear(); // 清理缓存
    }
}

及时清理不需要的对象

这个示例中，cache列表不断添加新对象，但没有进行清理。这样的话，随着时间的推移，cache列表的大小会不断增加，占用大量内存，可能导致系统性能问题。

java 复制代码 
public class MemoryLeakExample {
    private List<Object> cache = new ArrayList<>();

    public void process() {
        cache.add(new Object()); // 添加对象到缓存
        // 缓存不清理
    }
}

修改后的代码中process方法会定期检查cache大小。如果cache超过了设定的大小，就会调用clear方法来清空缓存。这可以帮助控制内存使用，避免列表无限增长。

java 复制代码 
public class MemoryLeakFixedExample {
    private List<Object> cache = new ArrayList<>();

    public void process() {
        cache.add(new Object());
        if (cache.size() > 100) {
            cache.clear(); // 定期清理缓存
        }
    }
}

避免无限增长

如果一个集合或缓存没有限制其大小且没有清理机制，它可能无限增加，导致不再需要的对象无法被垃圾回收，从而引发内存泄漏。这个示例中，data列表不断增加对象，没有进行任何限制或清理。这会导致data列表无限增长，逐渐消耗大量内存，最终可能导致内存不足。

java 复制代码 
public class InfiniteGrowthExample {
    private List<Object> data = new ArrayList<>();

    public void addData(Object obj) {
        data.add(obj); // 不断添加对象
        // 无限制增长
    }
}

这里使用LinkedList作为数据结构，并设置了最大大小限制。当列表的大小超过限制时，最旧的元素会被移除。这种做法可以控制内存的使用，避免数据结构无限增长。

java 复制代码 
public class BoundedGrowthExample {
    private List<Object> data = new LinkedList<>();

    public void addData(Object obj) {
        if (data.size() > 100) {
            data.remove(0); // 保持列表大小限制
        }
        data.add(obj);
    }
}

避免内部类持有外部类引用

匿名内部类Runnable持有对外部类实例的隐式引用。如果外部类的生命周期很长，可能导致外部类无法被垃圾回收，从而引发内存泄漏。

java 复制代码 
public class AnonymousInnerClassExample {
    public void process() {
        Runnable r = new Runnable() {
            public void run() {
                // 使用外部类的实例
            }
        };
        new Thread(r).start();
    }
}

在改进后的代码中，使用了lambda表达式，避免了匿名内部类带来的隐式引用。这样可以减少对外部类实例的持有，降低内存泄漏的风险。

java 复制代码 
public class AnonymousInnerClassFixedExample {
    public void process() {
        Runnable r = () -> {
            // 使用外部类的实例
        };
        new Thread(r).start();
    }
}

使用弱引用

弱引用是Java中的一种引用类型，用于在对象不再被强引用时允许垃圾回收器回收这些对象，它主要用于实现缓存和其他需要动态释放内存的场景。与强引用不同，弱引用在垃圾回收时不会阻止对象的回收。如果一个对象只有弱引用指向它，那么在垃圾回收时，这个对象会被回收。弱引用的设计目的是帮助避免内存泄漏。

java 复制代码 
public class WeakReferenceCache {
    private Map<String, WeakReference<Object>> cache = new HashMap<>();

    public void addToCache(String key, Object value) {
        cache.put(key, new WeakReference<>(value));
    }

    public Object getFromCache(String key) {
        WeakReference<Object> ref = cache.get(key);
        return (ref != null) ? ref.get() : null;
    }
}

尽管弱引用设计的目的是避免内存泄漏，但在以下情况下仍然可能出现问题：

  • 缓存失控：如果使用弱引用实现缓存，并且缓存管理策略不当，可能会导致频繁的对象创建和回收，影响性能。
    例如，缓存的对象如果不断被创建和清除，可能导致大量的对象创建压力，从而影响性能。
  • 内存使用不均：弱引用对象的回收是非确定性的。垃圾回收器的回收行为可能不一致，这可能导致应用程序的内存使用行为不如预期。

在这个示例中，clearCache方法会清空缓存。在大多数情况下，缓存中的对象会在下一次垃圾回收时被回收，但如果缓存使用不当，频繁的缓存清空操作可能会影响系统性能。

java 复制代码 
public class CacheWithPotentialIssues {
    private Map<String, WeakReference<Object>> cache = new HashMap<>();

    public void addToCache(String key, Object value) {
        cache.put(key, new WeakReference<>(value));
    }

    public Object getFromCache(String key) {
        WeakReference<Object> ref = cache.get(key);
        return (ref != null) ? ref.get() : null;
    }

    // 可能引起问题的代码
    public void clearCache() {
        cache.clear(); // 清空缓存
    }
}
相关推荐
KiddoStone8 分钟前
多实例schedule job同步数据流的数据一致性设计和实现方案
java
岁忧30 分钟前
(LeetCode 每日一题) 1865. 找出和为指定值的下标对 (哈希表)
java·c++·算法·leetcode·go·散列表
YuTaoShao33 分钟前
【LeetCode 热题 100】240. 搜索二维矩阵 II——排除法
java·算法·leetcode
考虑考虑1 小时前
JDK9中的dropWhile
java·后端·java ee
想躺平的咸鱼干2 小时前
Volatile解决指令重排和单例模式
java·开发语言·单例模式·线程·并发编程
hqxstudying2 小时前
java依赖注入方法
java·spring·log4j·ioc·依赖
·云扬·2 小时前
【Java源码阅读系列37】深度解读Java BufferedReader 源码
java·开发语言
Bug退退退1233 小时前
RabbitMQ 高级特性之重试机制
java·分布式·spring·rabbitmq
小皮侠3 小时前
nginx的使用
java·运维·服务器·前端·git·nginx·github
Zz_waiting.3 小时前
Javaweb - 10.4 ServletConfig 和 ServletContext
java·开发语言·前端·servlet·servletconfig·servletcontext·域对象
热门推荐
01集群聊天服务器---MySQL数据库的建立02GPU 进阶笔记（二）：华为昇腾 910B GPU03Coze扣子平台完整体验和实践（附国内和国际版对比）04使用Ruby接入实时行情API教程05Word粘贴时出现“运行时错误53,文件未找到：MathPage.WLL“的解决方案06扣子（coze）实战|我用扣子搭建了一个自动分析小红薯笔记内容的AI应用|详细步骤拆解07Java学习第十五部分——MyBatis08扣子空间的使用教程与大模型技术思考09DeepSeek各版本说明与优缺点分析10基于odoo17的设计模式详解---装饰模式