Java WeakHashMap 源码解析

1Object o = new Object();

 1    //referent 为引用指向的对象
 2    Reference(T referent) {
 3        this(referent, null);
 4    }
 5    //ReferenceQueue对象，可以简单理解为一个队列
 6    //GC 在检测到appropriate reachability changes之后，
 7    //会把引用对象本身添加到这个queue中，便于清理引用对象本身
 8    Reference(T referent, ReferenceQueue<? super T> queue) {
 9        this.referent = referent;
10        this.queue = (queue == null) ? ReferenceQueue.NULL : queue;
11    }

1Object o = new Object();
2SoftReference<Object> sr = new SoftReference<>(o , queue);

 1   /**
 2     * The entries in this hash table extend WeakReference, using its main ref
 3     * field as the key.
 4     */
 5    private static class Entry<K,V> extends WeakReference<Object> implements Map.Entry<K,V> {
 6        V value;
 7        int hash;
 8        Entry<K,V> next;
 9
10        /**
11         * Creates new entry.
12         */
13        Entry(Object key, V value,
14              ReferenceQueue<Object> queue,
15              int hash, Entry<K,V> next) {
16            //这里把key传给了父类WeakReference，说明key为弱引用（没有显式的 this.key = key）
17            //所有如果key只有通过弱引用访问时，key会被 GC 清理掉
18            //同时该key所代表的Entry会进入queue中，等待被处理
19            //还可以看到value为强引用（有显式的 this.value = value ），但这并不影响
20            //后面可以看到WeakHashMap.expungeStaleEntries方法是如何清理value的
21            super(key, queue);
22            this.value = value;
23            this.hash  = hash;
24            this.next  = next;
25        }
26
27        @SuppressWarnings("unchecked")
28        //在获取key时需要unmaskNull，因为对于null的key，是用WeakHashMap的内部成员属性来表示的
29        public K getKey() {
30            return (K) WeakHashMap.unmaskNull(get());
31        }
32
33        public V getValue() {
34            return value;
35        }
36
37        public V setValue(V newValue) {
38            V oldValue = value;
39            value = newValue;
40            return oldValue;
41        }
42        public boolean equals(Object o) {
43            if (!(o instanceof Map.Entry))
44                return false;
45            Map.Entry<?,?> e = (Map.Entry<?,?>)o;
46            K k1 = getKey();
47            Object k2 = e.getKey();
48            if (k1 == k2 || (k1 != null && k1.equals(k2))) {
49                V v1 = getValue();
50                Object v2 = e.getValue();
51                if (v1 == v2 || (v1 != null && v1.equals(v2)))
52                    return true;
53            }
54            return false;
55        }
56
57        public int hashCode() {
58            K k = getKey();
59            V v = getValue();
60            return ((k==null ? 0 : k.hashCode()) ^
61                    (v==null ? 0 : v.hashCode()));
62        }
63
64        public String toString() {
65            return getKey() + "=" + getValue();
66        }
67    }

 1    /**
 2     * Reference queue for cleared WeakEntries
 3     */
 4    // 所有Entry在构造时都传入该queue
 5    private final ReferenceQueue<Object> queue = new ReferenceQueue<>();
 6
 7    /**
 8     * Expunges stale entries from the table.
 9     */
10    private void expungeStaleEntries() {
11        for (Object x; (x = queue.poll()) != null; ) {
12            synchronized (queue) {
13                // e 为要清理的对象
14                @SuppressWarnings("unchecked")
15                    Entry<K,V> e = (Entry<K,V>) x;
16                int i = indexFor(e.hash, table.length);
17
18                Entry<K,V> prev = table[i];
19                Entry<K,V> p = prev;
20                // while 循环遍历冲突链
21                while (p != null) {
22                    Entry<K,V> next = p.next;
23                    if (p == e) {
24                        if (prev == e)
25                            table[i] = next;
26                        else
27                            prev.next = next;
28                        // Must not null out e.next;
29                        // stale entries may be in use by a HashIterator
30                        // 可以看到这里把value赋值为null，来帮助 GC 回收强引用的value
31                        e.value = null; // Help GC
32                        size--;
33                        break;
34                    }
35                    prev = p;
36                    p = next;
37                }
38            }
39        }
40    }

 1import java.util.WeakHashMap;
 2
 3class KeyHolder {
 4    @Override
 5    protected void finalize() throws Throwable {
 6        System.out.println("I am over from key");
 7        super.finalize();
 8    }
 9}
10class ValueHolder {
11    @Override
12    protected void finalize() throws Throwable {
13        System.out.println("I am over from value");
14        super.finalize();
15    }
16}
17
18public class RefTest {
19    public static void main(String[] args) {
20        WeakHashMap<KeyHolder, ValueHolder> weakMap = new WeakHashMap<KeyHolder, ValueHolder>();
21
22        KeyHolder kh = new KeyHolder();    
23        ValueHolder vh = new ValueHolder();
24
25        weakMap.put(kh, vh);
26
27        while (true) {
28            for (KeyHolder key : weakMap.keySet()) {
29                System.out.println(key + " : " + weakMap.get(key));
30            }
31            try {
32                Thread.sleep(2000);
33            } catch (InterruptedException e) {
34                e.printStackTrace();
35            }
36            System.out.println("here...");
37            //这里把kh设为null，这样一来就只有弱引用指向kh指向的对象
38            kh = null;
39            System.gc();
40        }
41    }
42}