Java WeakHashMap值引用键致内存泄漏的解决方案咨询

当WeakHashMap的值强引用键时，键会因为值的强引用而始终处于强可达状态，无法被GC回收，最终引发内存泄漏。要在不修改原键/值类的前提下解决这个问题，核心是打破值到键的强引用链，同时保证键强可达时能正常访问值。以下是具体实现方案：

核心方案：用WeakReference包装值中的键引用 #

直接在值的包装类中用WeakReference持有键，替代原有的强引用，这样值对键的引用不会阻止键被GC回收。同时WeakHashMap本身的键是弱引用，当外部没有键的强引用时，键会被GC，WeakHashMap会自动移除对应的条目。

代码示例 #

import java.lang.ref.WeakReference;
import java.util.WeakHashMap;

// 包装值的类，持有键的弱引用
class ValueWrapper<V, K> {
    private final V originalValue;
    private final WeakReference<K> keyRef;

    public ValueWrapper(V originalValue, K key) {
        this.originalValue = originalValue;
        this.keyRef = new WeakReference<>(key);
    }

    // 对外提供值的访问入口
    public V getValue() {
        return originalValue;
    }

    // 如需访问键，通过弱引用获取（可能返回null，需处理）
    public K getKey() {
        return keyRef.get();
    }
}

// 使用示例
public class WeakHashMapLeakFix {
    private final WeakHashMap<MyKey, ValueWrapper<MyValue, MyKey>> map = new WeakHashMap<>();

    public void put(MyKey key, MyValue value) {
        map.put(key, new ValueWrapper<>(value, key));
    }

    public MyValue get(MyKey key) {
        ValueWrapper<MyValue, MyKey> wrapper = map.get(key);
        return wrapper != null ? wrapper.getValue() : null;
    }

    // 原键类（无需修改）
    static class MyKey {
        private final String id;
        public MyKey(String id) { this.id = id; }
        
        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            MyKey myKey = (MyKey) o;
            return id.equals(myKey.id);
        }

        @Override
        public int hashCode() { return id.hashCode(); }
    }

    // 原值类（无需修改）
    static class MyValue {
        private final String data;
        public MyValue(String data) { this.data = data; }
    }
}

进阶优化：结合ReferenceQueue主动清理无效条目 #

WeakHashMap会在调用get()/put()/size()等方法时自动清理已被GC的键对应的条目，但如果长时间不操作map，可能会残留少量无效条目。可以结合ReferenceQueue和后台线程主动清理：

代码示例 #

import java.lang.ref.ReferenceQueue;
import java.lang.ref.WeakReference;
import java.util.WeakHashMap;

// 带引用队列的键包装类
class TrackedWeakKey<K> extends WeakReference<K> {
    private final int keyHashCode;

    public TrackedWeakKey(K key, ReferenceQueue<? super K> queue) {
        super(key, queue);
        this.keyHashCode = key.hashCode();
    }

    // 缓存hashCode，避免键被GC后无法匹配
    @Override
    public int hashCode() {
        return keyHashCode;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj instanceof TrackedWeakKey<?> other) {
            K thisKey = this.get();
            K otherKey = other.get();
            return thisKey != null && otherKey != null && thisKey.equals(otherKey);
        }
        return false;
    }
}

public class ActiveCleanupWeakHashMap {
    private final WeakHashMap<TrackedWeakKey<MyKey>, ValueWrapper<MyValue, MyKey>> map = new WeakHashMap<>();
    private final ReferenceQueue<MyKey> cleanupQueue = new ReferenceQueue<>();

    public ActiveCleanupWeakHashMap() {
        // 启动后台清理线程
        Thread cleanupThread = new Thread(() -> {
            while (!Thread.currentThread().isInterrupted()) {
                try {
                    // 等待被GC的键引用进入队列
                    TrackedWeakKey<MyKey> removedKey = (TrackedWeakKey<MyKey>) cleanupQueue.remove();
                    map.remove(removedKey);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        }, "WeakHashMap-Cleaner");
        cleanupThread.setDaemon(true);
        cleanupThread.start();
    }

    public void put(MyKey key, MyValue value) {
        TrackedWeakKey<MyKey> weakKey = new TrackedWeakKey<>(key, cleanupQueue);
        map.put(weakKey, new ValueWrapper<>(value, key));
    }

    public MyValue get(MyKey key) {
        for (var entry : map.entrySet()) {
            TrackedWeakKey<MyKey> weakKey = entry.getKey();
            MyKey actualKey = weakKey.get();
            if (actualKey != null && actualKey.equals(key)) {
                return entry.getValue().getValue();
            }
        }
        return null;
    }

    // 原键/值类同前，无需修改
    static class MyKey { /* ... */ }
    static class MyValue { /* ... */ }
}

方案说明 #

1. 无侵入性：原键类MyKey和值类MyValue完全不需要修改，仅通过包装类实现逻辑。
2. 内存安全：值对键的引用改为弱引用后，键仅保留WeakHashMap的弱引用，当外部无强引用时会被GC回收，WeakHashMap的对应条目也会被自动/主动清理。
3. 可用性：当键处于强可达状态时，通过getValue()可正常访问值，getKey()也能获取到键（需处理null情况）。

内容的提问来源于stack exchange，提问作者lelmarir