你是不是也曾經因為內存泄漏問題熬夜加班？我第一次遇到這個問題是在開發一個緩存系統時，明明已經不用的對象卻怎麼都釋放不掉。在 Java 開發中，合理管理內存資源是個大問題。傳統的 HashMap 會一直持有鍵值對的強引用，即使外部已經不再使用這些對象。而 WeakHashMap 正好能解決這個煩惱，它能自動感知對象的生命週期，幫我們處理那些不再需要的數據。

WeakHashMap 是什麼？

WeakHashMap 是 Java 集合框架中的一個特殊實現，它最大的特點是對鍵的引用是弱引用（Weak Reference）。這意味着什麼呢？簡單説，當某個鍵不再被程序中其他地方引用時，這個鍵值對會被自動從 WeakHashMap 中刪除，我們不需要手動去清理它。

graph LR
    A[普通對象] -->|強引用| B[HashMap的鍵]
    C[普通對象] -.->|弱引用| D[WeakHashMap的鍵]
    E[垃圾回收器] -->|可以回收| D
    E -.-x|不會回收| B

WeakHashMap 的工作原理

WeakHashMap 的工作方式跟 HashMap 很像，但內部實現大不相同。它的 Entry 類繼承自 WeakReference<K>，這使得鍵對象被弱引用包裝。當 Java 進行垃圾回收時，如果發現 WeakHashMap 中某個鍵只剩下弱引用（也就是沒有其他強引用了），JVM 就會回收這個鍵對象。

classDiagram
    class Map {
        <<interface>>
    }
    class AbstractMap
    class WeakReference
    class Entry~K,V~ {
        +value: V
        +next: Entry~K,V~
        +hash: int
    }
    class WeakHashMap {
        -table: Entry[]
        -queue: ReferenceQueue
        -expungeStaleEntries()
    }

    Map <|-- AbstractMap
    AbstractMap <|-- WeakHashMap
    WeakReference <|-- Entry
    WeakHashMap o-- Entry

源碼看工作流程

WeakHashMap 使用ReferenceQueue來跟蹤已被回收的鍵。核心流程是這樣的：

// 1. 在每次操作前，WeakHashMap都會先清理已回收的鍵
public V get(Object key) {
    Object k = maskNull(key);  // 特殊處理null鍵
    expungeStaleEntries();  // 先清理已被GC回收的鍵
    // 然後才執行查找...
}

// 特殊處理：WeakHashMap的null鍵會被包裝為內部對象
private static final Object NULL_KEY = new Object();
private static Object maskNull(Object key) {
    return (key == null) ? NULL_KEY : key;
}

// 2. 清理邏輯 - 檢查引用隊列中的失效引用
private void expungeStaleEntries() {
    // 從隊列中獲取已被GC回收的Entry
    for (Object x; (x = queue.poll()) != null; ) {
        synchronized (queue) {  // 確保隊列操作的線程安全
            @SuppressWarnings("unchecked")
            Entry<K,V> e = (Entry<K,V>) x;

            // 從哈希表中移除對應的鍵值對
            int i = indexFor(e.hash, table.length);
            Entry<K,V> prev = table[i];
            Entry<K,V> p = prev;
            // 查找並移除已失效的Entry
            while (p != null) {
                Entry<K,V> next = p.next;
                if (p == e) {
                    if (prev == e)
                        table[i] = next;
                    else
                        prev.next = next;
                    e.value = null; // 幫助GC回收值
                    size--;
                    break;
                }
                prev = p;
                p = next;
            }
        }
    }
}

這裏有幾個要點：

1. 清理不是實時的：WeakHashMap 只在你操作它時才會清理失效的鍵值對
2. 清理是自動的：不需要像普通 Map 那樣手動移除不用的對象
3. 同步處理：清理時會對引用隊列加鎖，確保多線程環境下的安全操作
4. null 鍵處理：null 鍵會被包裝為一個特殊對象（NULL_KEY），這個對象是強引用，所以 null 鍵不會被自動回收

WeakHashMap 和 HashMap：有啥不同？

想知道 WeakHashMap 和普通 HashMap 有什麼區別？下面這個表格一目瞭然：

多線程環境怎麼用

WeakHashMap 本身不是線程安全的，在多線程環境下需要額外處理。常用的方案有：

// 方案1: 最簡單的做法
Map<Key, Value> map = Collections.synchronizedMap(new WeakHashMap<>());

// 方案2: 讀多寫少場景的更好選擇
public class ThreadSafeWeakCache<K, V> {
    private final WeakHashMap<K, V> map = new WeakHashMap<>();
    private final ReadWriteLock lock = new ReentrantReadWriteLock();

    public V get(K key) {
        lock.readLock().lock();
        try {
            return map.get(key);
        } finally {
            lock.readLock().unlock();
        }
    }

    public V put(K key, V value) {
        lock.writeLock().lock();
        try {
            return map.put(key, value);
        } finally {
            lock.writeLock().unlock();
        }
    }
}

方案 1 簡單直接，方案 2 在讀操作特別多的情況下性能更好。根據自己的場景選擇吧！

實際使用場景

場景一：簡單緩存

假設我們需要一個簡單的緩存，但又不想手動管理緩存清理：

public class SimpleCache<K, V> {
    private final WeakHashMap<K, V> cacheMap = new WeakHashMap<>();

    public void put(K key, V value) {
        if (key == null) throw new NullPointerException("Key不能為null");
        cacheMap.put(key, value);
    }

    public V get(K key) {
        return cacheMap.get(key);
    }

    // 比size()更準確的判斷方法
    public boolean contains(K key) {
        return cacheMap.get(key) != null;
    }
}

這種緩存不需要我們關心內存釋放，鍵對象不再使用時自然就會被清理掉。

場景二：對象關聯數據

當我們需要給對象臨時關聯一些額外數據，但不想影響對象本身的生命週期：

public class ObjectMetadata {
    // 存儲對象關聯數據
    private static final Map<Object, Object> dataMap = new WeakHashMap<>();

    public static void setData(Object obj, Object data) {
        if (obj == null) throw new NullPointerException("對象不能為null");
        dataMap.put(obj, data);
    }

    public static Object getData(Object obj) {
        return dataMap.get(obj);
    }
}

這種方式的優點是：當關聯的對象被回收，關聯的數據也會自動從 map 中移除。

注意：如果值對象（data）被其他地方強引用，即使鍵對象（obj）被回收，值對象仍會留在內存中，但 WeakHashMap 會移除對應的鍵值對。這不會影響鍵的回收。

// 值被外部引用的情況
Object data = new Object(); // 這個對象被外部強引用
Object obj = new Object();
ObjectMetadata.setData(obj, data);
obj = null; // 鍵對象可以被回收，但data仍留在內存中

場景三：事件監聽器管理

在事件系統中避免監聽器引起的內存泄漏：

public class EventManager {
    // 使用WeakHashMap存儲監聽器
    private final Map<Object, Set<EventHandler>> listeners =
            Collections.synchronizedMap(new WeakHashMap<>());

    public void addListener(Object source, EventHandler handler) {
        // 使用CopyOnWriteArraySet確保線程安全的迭代
        listeners.computeIfAbsent(source, k -> new CopyOnWriteArraySet<>()).add(handler);
    }

    public void fireEvent(Object source, Event event) {
        // 用HashMap創建快照，避免遍歷時鍵被回收的問題
        Map<Object, Set<EventHandler>> snapshot;
        synchronized (listeners) {
            snapshot = new HashMap<>(listeners);
        }

        Set<EventHandler> handlers = snapshot.get(source);
        if (handlers != null) {
            for (EventHandler handler : handlers) {
                handler.handle(event);
            }
        }
    }

    // 接口定義
    public interface EventHandler {
        void handle(Event event);
    }

    public static class Event { /* 事件數據 */ }
}

這種設計讓監聽器能隨着事件源對象的回收而自動註銷，不會造成內存泄漏。

使用誤區和解決辦法

1. 值引用鍵造成的內存泄漏

有個常見的錯誤：讓值對象引用了鍵對象，導致鍵無法被垃圾回收。

// 錯誤示例
Key key = new Key("data");
WeakHashMap<Key, ValueWrapper> map = new WeakHashMap<>();
map.put(key, new ValueWrapper(key));  // 值引用了鍵！
key = null;  // 外部引用斷開，但鍵仍不會被回收

class ValueWrapper {
    private final Key keyRef;  // 值引用了鍵，形成強引用鏈
    ValueWrapper(Key key) {
        this.keyRef = key;
    }
}

解決辦法：確保值對象不要引用鍵對象，打破引用鏈。

2. 字符串常量作鍵的問題

// 錯誤示例
WeakHashMap<String, Data> map = new WeakHashMap<>();
map.put("常量字符串", new Data());  // 這個鍵永遠不會被回收

字符串字面量會存在於常量池中，它們通常有永久性的強引用，使用它們作為鍵會導致 WeakHashMap 失去自動清理的優勢。

解決辦法：使用新創建的字符串對象作為鍵。

// 正確做法
String key = new String("臨時字符串");  // 創建非常量池的新對象
map.put(key, new Data());

3. 依賴 size()判斷存在性

// 錯誤示例
map.put(key, value);
System.gc();
System.out.println("Map是否為空: " + (map.size() > 0));  // 不可靠！

由於 WeakHashMap 的清理是惰性的，size()方法可能返回的數字包含了已失效但尚未清理的鍵值對。

解決辦法：使用get(key) != null或containsKey(key)判斷鍵是否存在。

性能注意事項

WeakHashMap 相比 HashMap 有性能開銷，主要原因是：

1. 每次操作觸發清理：所有操作前都要執行expungeStaleEntries()，遍歷引用隊列和部分哈希表
2. 弱引用處理開銷：鍵需要包裝為 WeakReference，增加了對象創建和引用隊列處理成本

性能對比數據：

• get操作：WeakHashMap 比 HashMap 慢約 12-15%
• put操作：WeakHashMap 比 HashMap 慢約 18-22%

當垃圾回收頻繁時，性能差距更明顯。測試中，讓 100%的鍵同時失效後，WeakHashMap 的後續操作可能慢 30%以上，因為需要清理大量失效鍵值對。

生產環境建議：

• 對性能要求高的核心模塊，避免使用 WeakHashMap
• 考慮定期手動觸發清理（如map.size()），避免清理操作集中影響性能
• 高頻操作場景，可以用軟引用緩存或手動管理生命週期替代

實用代碼：健壯的圖片緩存

下面是一個優化過的圖片緩存實現，避開了各種常見問題：

import java.util.Collections;
import java.util.Map;
import java.util.WeakHashMap;

public class ImageCache {
    // 線程安全的WeakHashMap
    private final Map<String, byte[]> cache =
            Collections.synchronizedMap(new WeakHashMap<>());

    public void cacheImage(String key, byte[] imageData) {
        if (key == null || imageData == null) {
            throw new IllegalArgumentException("鍵和圖片數據不能為null");
        }

        // 創建新字符串對象作為鍵
        // 注：若確定key不是字符串常量（如UUID.randomUUID().toString()），可直接使用key
        String cacheKey = new String(key);
        cache.put(cacheKey, imageData);
    }

    public byte[] getImage(String key) {
        if (key == null) return null;
        return cache.get(key);
    }

    public boolean hasImage(String key) {
        if (key == null) return false;
        return cache.get(key) != null;
    }

    // 查看當前有效圖片數量（訪問開銷大，慎用）
    public int countValidImages() {
        int count = 0;
        synchronized (cache) {
            for (String key : cache.keySet()) {
                if (cache.get(key) != null) {
                    count++;
                }
            }
        }
        return count;
    }
}

這個緩存的特點：

1. 線程安全
2. 避免了常量池字符串問題
3. 圖片數據會隨鍵的回收自動釋放
4. 提供了準確的存在性判斷方法

不同引用類型的選擇

Java 提供了四種引用類型，各有不同用途：

graph TD
    A[引用類型選擇] --> B{需要自動回收嗎?}
    B -->|不需要| C[強引用 HashMap]
    B -->|需要| D{回收時機?}
    D -->|內存不足時| E[軟引用 SoftReference]
    D -->|對象不用時| F[弱引用 WeakHashMap]
    D -->|僅跟蹤釋放| G[虛引用 PhantomReference]

選擇標準簡單明瞭：

• 強引用：核心數據、永久數據，使用 HashMap
• 軟引用：緩存數據，但希望儘可能長保留，內存不足才釋放
• 弱引用：臨時關聯數據，對象不用就丟，使用 WeakHashMap
• 虛引用：僅用於跟蹤對象被回收的時機，無法通過引用獲取對象，常用於直接內存管理

總結

WeakHashMap 的關鍵特點和使用方法總結如下：