WeakHashMap

1. 简介

WeakHashMap 是一种使用弱项(WeakEntry)的哈希映射表,本质上是一种特殊的HashMap,其关于哈希表部分的实现与HashMap 没有什么不同,而弱项就是使用弱引用实例作为 Map 的表项(表元素)。

2. WeakHashMap弱项的实现

WeakHashMap 的表项类型 Entry 继承了弱引用类 java.lang.ref.WeakReference代码1),并且内部维护了一个引用队列 queue代码2),是 java.lang.ref.ReferenceQueue 的实例,用于收集被 GC 回收了弱键的表项 。

public class WeakHashMap extends AbstractMap implements Map {
    ...
     /**
     * Reference queue for cleared WeakEntries
     */
    1. private final ReferenceQueue queue = new ReferenceQueue<>();
    ...
    2. private static class Entry extends WeakReference implements Map.Entry {
        V value;
        final int hash;
        Entry next;

        /**
         * Creates new entry.
         */
        Entry(Object key, V value, ReferenceQueue queue, int hash, Entry next) {
            super(key, queue);
            this.value = value;
            this.hash  = hash;
            this.next  = next;
        }

        ...
    }
    ...
    /**
     * Expunges stale entries from the table.
     */
    3. private void expungeStaleEntries() {
        for (Object x; (x = queue.poll()) != null; ) {
            synchronized (queue) {
                @SuppressWarnings("unchecked")
                    Entry e = (Entry) x;
                int i = indexFor(e.hash, table.length);

                Entry prev = table[i];
                Entry p = prev;
                while (p != null) {
                    Entry next = p.next;
                    if (p == e) {
                        if (prev == e)
                            table[i] = next;
                        else
                            prev.next = next;
                        // Must not null out e.next;
                        // stale entries may be in use by a HashIterator
                        e.value = null; // Help GC
                        size--;
                        break;
                    }
                    prev = p;
                    p = next;
                }
            }
        }
    }
    /**
     * Returns the table after first expunging stale entries.
     */
    private Entry[] getTable() {
        expungeStaleEntries();
        return table;
    }
    ...
}

所以每一个表项 Entry 本身就是一个弱引用实例,Entry 的构造函数通过调用父类 WeakReference 构造函数 super(key, queue) 将表项的键 key 的值关联到弱引用上;所以当我们将键值对放入到 WeakHashMap 中时,WeakHashMap 使用弱引用 Entry 来持有 key,这不同于 HashMapHashMap 是在 Entry 对象中用强引用来持有 key)。所以一旦某个键在 WeakHashMap 外部没有其他强引用关联,GC 就会将该键回收,同时将该键关联的弱引用实例添加到注册的引用队列queue中,尽管该键并未从WeakHashMap 中移除。虽然 key 已经被回收了,但是表项 Entry 还保存在 WeakHashMap 中,所以WeakHashMap 在进行每一次操作之前,都要进行数据同步工作,就是将被GC回收了键对象的Entry实例(保存在 queue 里面)从WeakHashMap 中移除(代码3)。

3. WeakHashMap应用

前文我们讲解了 WeakHashMap 弱项的实现,因为 WeakHashMap 的弱项本质上是弱引用实例,所以它的键在下一次 GC 时间就会被回收。那么 WeakHashMap 适合用在什么地方呢?有些书根据 WeakHashMap 弱项的特性,认为 WeakHashMap 适合用来做缓存,但是如果直接用 WeakHashMap 做缓存,可能会有以下几个问题:

  • 因为弱项在下一次 GC 就会被回收,所以缓存元素的生命周期太短,并且无论元素的使用频率如何,都会在下一次 GC 被回收,会导致缓存命中率过低。
  • 缓存元素过期时间不可控,因为使用 WeakHashMap 做缓存时,完全依赖 GC 时间和频率来控制元素的过期时间,这对用户来说时透明的,是不可控制的。
  • WeakHashMap 每次访问 WeakHashMap 时,都会触发数据同步工作 expungeStaleEntries,通过其实现源码,我们看到这个方法还是比较耗时的,因此如果用 WeakHashMap 做缓存,尤其是实时性要求较高的场景,会有性能方面的问题
  • 由于弱项本质上是弱引用实例,是一种特殊引用,JVM 在每一个 GC 周期,都会有专门的时间周期对这些特殊引用进行特殊处理(是引用处理 Ref Proc 和引用排队 Ref Enq 两个处理阶段),如果缓存中的元素数量比较多时,就会出现大量的弱引用实例,这会导致这两个处理阶段耗时较高。

我们看到,用 WeakHashMap 直接做缓存会有很多问题,所以 WeakHashMap 不适合用来做直接缓存,但是 WeakHashMap 特别适合来做辅助缓存。比如下面的例子,我们开发了一个有回收站功能的缓存,主缓存功能使用 Guava 的缓存实现,回收站缓存使用 WeakHashMap 实现。当主缓存 mainCache 中某个键过期后,缓存并没有将其直接放弃,而是先移动到回收站 recycleBin 中,在下一次 GC 时间来临之前,如果这个键被重新访问了,那么就会被从回收站中复活,重新被放入缓存中,否则,这个键会在下一次 GC 时被回收,辅助回收站的设计可以有效提高缓存的命中率。
这样设计的主要基本思路在于弱可达与不可达的区别:由于 JVMGC 需要在某些条件下才触发,所以,当缓存中的元素过期之后,一般会将该元素移除,使其变为不可达对象,等待 GC 回收,但是 GC 并不会马上回收,需要等待进入下一次 GC 时间,在下一次 GC 来临之前的这段时间,虽然对象是不可达的,但它仍然会保存在内存中,而且在这段时间内,已经过期的元素也有被重新访问的可能性,所以为了充分利用这段时间,可以将过期的元素先用弱引用关联起来,虽然对于过期的元素来说,即使有了弱引用,也会在下次GC被回收,但其区别在于,在过期的元素被回收之前,可以通过弱引用获取到该对象,并关联到其他强引用来拯救该对象,防止其被回收,但一个不可达的对象,由于已经无法通过 GC Roots 访问,所以已经无法被拯救了。

/**
 * 携带回收站的缓存
 */
public class MyCache extends CacheLoader implements RemovalListener{

    private ScheduledExecutorService cacheExecutor = Executors.newScheduledThreadPool(1);

    private final LoadingCache mainCache = CacheBuilder.
            newBuilder().
            expireAfterAccess(1, TimeUnit.MINUTES).
            removalListener(RemovalListeners.asynchronous(this, this.cacheExecutor)).
            build(this);

    private final WeakHashMap recycleBin = new WeakHashMap();

    public MyCache() {
        super();
        this.cacheExecutor.scheduleAtFixedRate(this.mainCache::cleanUp, 1, 1, TimeUnit.MINUTES);
    }
    
    public Object get(String key) {
        try {
            return this.mainCache.get(key);
        } catch (ExecutionException e) {}
        return null;
    }
    
    public void put(String key, Object value) {
        this.mainCache.put(key, value);
    }
    
    @Override
    public synchronized Object load(String key) throws Exception {
        return this.recycleBin.remove(key);
    }

    @Override
    public synchronized void onRemoval(RemovalNotification notification) {
        this.recycleBin.put(notification.getKey(), notification.getValue());
    }
}

你可能感兴趣的:(WeakHashMap)