概述
内存泄漏是指不使用的对象持续占有内存使得内存得不到释放,从而造成内存空间的浪费。内存泄露最明显问题频繁GC,从而STW
次数增加,导致用户体验变差。如果内存泄露问题严重,会导致OOM,直接导致程序不能正常运行。
大多数内存泄露的原因是,长生命周期的对象引用了短生命周期的对象。例如,A对象引用B对象,A对象的生命周期(t1-t4)比B对象的生命周期(t2-t3)长的多。当B对象没有被应用程序使用之后,A对象仍然在引用着B对象。这样,垃圾回收器就没办法将B对象从内存中移除,从而导致内存泄露问题。
所以减少长生命周期对象持有短生命周期对象的强引用是一个关键点。利用弱引用或者软引用可以让垃圾回收器更容易回收不再需要的对象。对于外部资源,如数据库连接、文件、网络连接,用完后应该及时关闭。try-with-resources
语句是管理这些资源的有效工具,同时移除不再需要的事件监听器也能防止内存泄漏。管理集合时,设定大小限制并定期清理过期数据可以避免无限增长。使用有界数据结构能帮助控制缓存的大小。静态集合要特别留意,避免它们占用过多内存,通过定期清理来管理数据的存储。通过这些措施,可以减少内存泄漏的风险。
及时释放资源
如数据库连接、网络连接和IO连接等,当不再使用时,需要调用close
方法来释放连接。只有连接被关闭后,垃圾回收器才会回收对应的对象。否则如果在连接过程中,对一些对象不显性地关闭,将会造成大量的对象无法被回收,从而引起内存泄漏。
在这个例子中,数据库连接conn
在方法结束时没有被关闭。这导致了连接资源的泄漏,因为即使在出现异常时也没有释放连接,可能会导致数据库连接池资源被耗尽,影响系统的正常运行。
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
块结束时被自动关闭,即使发生了异常也不会有资源泄漏的问题。
public class ResourceLeakFixedExample {
public void process() {
try (Connection conn = DriverManager.getConnection(url, user, password)) {
// 使用连接
} catch (SQLException e) {
e.printStackTrace();
}
// 连接自动关闭
}
}
设置合理的变量作用域
一个变量的定义的作用范围大于其使用范围,很有可能会造成内存泄漏。静态变量cache
持有所有添加对象的引用。由于这个集合是静态的,它会持续存在,导致对象不会被垃圾回收,可能导致内存使用逐渐增大,最终可能耗尽内存。
public class StaticCacheExample {
private static List<Object> cache = new ArrayList<>();
public static void addToCache(Object obj) {
cache.add(obj); // 对象添加到静态列表
}
}
可以将其作用域缩小,解决这个问题。在这个例子中,localCache
是一个局部变量,存在于方法的作用域内。当方法执行完毕后,localCache
变量会被垃圾回收器回收。通过调用clear
方法清空缓存,可以进一步减少内存占用。
public class LocalCacheExample {
public void process() {
List<Object> localCache = new ArrayList<>();
localCache.add(new Object());
// 使用 localCache
localCache.clear(); // 清理缓存
}
}
及时清理不需要的对象
这个示例中,cache
列表不断添加新对象,但没有进行清理。这样的话,随着时间的推移,cache
列表的大小会不断增加,占用大量内存,可能导致系统性能问题。
public class MemoryLeakExample {
private List<Object> cache = new ArrayList<>();
public void process() {
cache.add(new Object()); // 添加对象到缓存
// 缓存不清理
}
}
修改后的代码中process
方法会定期检查cache
大小。如果cache
超过了设定的大小,就会调用clear
方法来清空缓存。这可以帮助控制内存使用,避免列表无限增长。
public class MemoryLeakFixedExample {
private List<Object> cache = new ArrayList<>();
public void process() {
cache.add(new Object());
if (cache.size() > 100) {
cache.clear(); // 定期清理缓存
}
}
}
避免无限增长
如果一个集合或缓存没有限制其大小且没有清理机制,它可能无限增加,导致不再需要的对象无法被垃圾回收,从而引发内存泄漏。这个示例中,data
列表不断增加对象,没有进行任何限制或清理。这会导致data
列表无限增长,逐渐消耗大量内存,最终可能导致内存不足。
public class InfiniteGrowthExample {
private List<Object> data = new ArrayList<>();
public void addData(Object obj) {
data.add(obj); // 不断添加对象
// 无限制增长
}
}
这里使用LinkedList
作为数据结构,并设置了最大大小限制。当列表的大小超过限制时,最旧的元素会被移除。这种做法可以控制内存的使用,避免数据结构无限增长。
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
持有对外部类实例的隐式引用。如果外部类的生命周期很长,可能导致外部类无法被垃圾回收,从而引发内存泄漏。
public class AnonymousInnerClassExample {
public void process() {
Runnable r = new Runnable() {
public void run() {
// 使用外部类的实例
}
};
new Thread(r).start();
}
}
在改进后的代码中,使用了lambda
表达式,避免了匿名内部类带来的隐式引用。这样可以减少对外部类实例的持有,降低内存泄漏的风险。
public class AnonymousInnerClassFixedExample {
public void process() {
Runnable r = () -> {
// 使用外部类的实例
};
new Thread(r).start();
}
}
使用弱引用
弱引用是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
方法会清空缓存。在大多数情况下,缓存中的对象会在下一次垃圾回收时被回收,但如果缓存使用不当,频繁的缓存清空操作可能会影响系统性能。
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(); // 清空缓存
}
}