Java中如何创建内存泄漏

技术背景

在Java中，由于有垃圾回收机制（GC），通常情况下开发者无需手动管理内存。但在某些特定场景下，仍可能出现内存泄漏问题，即对象不再被使用，但由于某些原因无法被垃圾回收器回收，从而导致内存占用不断增加。

实现步骤

利用ThreadLocal和自定义ClassLoader创建内存泄漏

1. 创建长生命周期线程：应用程序创建一个长时间运行的线程（或使用线程池以更快地造成泄漏）。
2. 加载类：线程通过自定义的ClassLoader加载一个类。
3. 分配内存并存储引用：该类分配一大块内存（例如new byte[1000000]），将其强引用存储在静态字段中，然后将自身引用存储在ThreadLocal中。
4. 清除引用：应用程序清除对自定义类或加载它的ClassLoader的所有引用。
5. 重复操作：多次重复上述步骤，加剧内存泄漏。

静态字段持有对象引用

在类中定义一个静态的ArrayList，由于静态字段的生命周期与类相同，只要类不被卸载，该ArrayList就会一直存在于内存中。

class MemorableClass {
    static final ArrayList list = new ArrayList(100);
}

未关闭的流和连接

在使用文件流、网络流或数据库连接时，如果没有正确关闭，会导致资源无法释放，造成内存泄漏。

// 未关闭文件流
try {
    BufferedReader br = new BufferedReader(new FileReader(inputFile));
    // ...
} catch (Exception e) {
    e.printStackTrace();
}

// 未关闭数据库连接
try {
    Connection conn = ConnectionFactory.getConnection();
    // ...
} catch (Exception e) {
    e.printStackTrace();
}

错误的hashCode()和equals()实现

使用HashSet或HashMap时，如果键的hashCode()和equals()方法实现不正确，会导致集合不断增长，无法正确处理重复元素。

class BadKey {
    // 没有重写hashCode()和equals()方法
    public final String key;
    public BadKey(String key) { this.key = key; }
}

Map map = System.getProperties();
map.put(new BadKey("key"), "value");

File.deleteOnExit()问题

调用File.deleteOnExit()会导致字符串泄漏，在Java 7之前，如果字符串是子字符串，泄漏会更严重。

Runtime.addShutdownHook未移除

使用Runtime.addShutdownHook添加钩子后，如果没有正确移除，可能会导致ThreadGroup泄漏。

未启动的线程

创建但未启动的线程也可能导致内存泄漏，因为线程会继承ContextClassLoader、AccessControlContext等引用。

ThreadLocal缓存

如果线程的生命周期超过了上下文类加载器的生命周期，ThreadLocal缓存可能会导致内存泄漏。

错误使用WeakHashMap

当WeakHashMap的值直接或间接引用其键时，会导致难以发现的内存泄漏。

使用java.net.URL

使用java.net.URL加载HTTP(S)资源时，KeepAliveCache会创建一个新线程，可能会泄漏当前线程的上下文类加载器。

InflaterInputStream和Deflater未正确关闭

在使用InflaterInputStream和Deflater时，如果没有调用end()方法，会导致本地内存泄漏。

核心代码

以下是利用ThreadLocal和自定义ClassLoader创建内存泄漏的示例代码：

import java.lang.ref.WeakReference;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class MemoryLeakExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 1000; i++) {
            executor.submit(() -> {
                CustomClassLoader classLoader = new CustomClassLoader();
                try {
                    Class<?> clazz = classLoader.loadClass("LeakyClass");
                    Object instance = clazz.newInstance();
                } catch (Exception e) {
                    e.printStackTrace();
                }
                // 清除对ClassLoader的引用
                classLoader = null;
            });
        }
        executor.shutdown();
    }
}

class CustomClassLoader extends ClassLoader {
    @Override
    public Class<?> loadClass(String name) throws ClassNotFoundException {
        // 自定义类加载逻辑
        return super.loadClass(name);
    }
}

class LeakyClass {
    private static final ThreadLocal<LeakyClass> threadLocal = new ThreadLocal<>();
    private static final byte[] largeArray = new byte[1000000];

    public LeakyClass() {
        threadLocal.set(this);
    }
}

最佳实践

• 及时关闭资源：在使用文件流、网络流、数据库连接等资源时，确保在使用完毕后及时关闭。可以使用try-with-resources语句简化资源管理。

try (BufferedReader br = new BufferedReader(new FileReader(inputFile))) {
    // 处理文件内容
} catch (IOException e) {
    e.printStackTrace();
}

• 正确实现hashCode()和equals()方法：在使用集合类时，确保键对象正确实现了hashCode()和equals()方法。
• 合理使用ThreadLocal：避免在长生命周期的线程中使用ThreadLocal缓存，或者在不需要时及时清除ThreadLocal中的数据。
• 使用合适的缓存策略：对于缓存对象，使用具有缓存淘汰机制的缓存实现，如LRUMap。

常见问题

如何检测内存泄漏？

可以使用Java的内存分析工具，如VisualVM、YourKit等，通过分析堆转储文件来查找内存泄漏的对象。

为什么现代JVM不会因为循环引用而导致内存泄漏？

现代JVM通常使用标记-清除或标记-整理等垃圾回收算法，而不是引用计数算法。这些算法可以正确处理循环引用的对象，将其标记为可回收对象。

如何避免因第三方库导致的内存泄漏？

在使用第三方库时，仔细阅读文档，了解其使用注意事项。如果发现库存在内存泄漏问题，可以尝试升级到最新版本或寻找替代库。