Java中的引用类型（强引用、软引用、弱引用、虚引用）介绍，示例WeakHashMap的使用【享学Java】（下）

// @since 1.2  JDK1.2出来的
public class WeakHashMap<K,V> extends AbstractMap<K,V> implements Map<K,V> {
  // 内部自己new了一个ReferenceQueue
    private final ReferenceQueue<Object> queue = new ReferenceQueue<>();
  ...
  // 它使用若引用的核心主要是Entry这个内类
  // 继承自WeakReference，这样一来，整个Entry就是一个WeakReferenc
    private static class Entry<K,V> extends WeakReference<Object> implements Map.Entry<K,V> {
        Entry(Object key, V value,ReferenceQueue<Object> queue,int hash, Entry<K,V> next) {
            super(key, queue); // 调用WeakReference的构造函数
            this.value = value;
            this.hash  = hash;
            this.next  = next;
        }
    }
  ...
}

public class Main {
    public static void main(String[] args) throws InterruptedException {
        // 只改变了这一句话而已~
        Map<String, Object> map = new WeakHashMap<>();
        for (int i = 0; i < 10000; i++) {
            map.put("key" + i, new byte[i]);
        }
        System.out.println(map.size());
    }
}

6（备注：这个值可能是10、20、100等等）

public class SoftReferenceCache<K, V> {
    private static final int DEFAULT_MAP_SIZE = 1024; // 初始容量
    private Map<K, CacheReference<K, V>> softReferenceMap = new HashMap<>(DEFAULT_MAP_SIZE);
    private final ReferenceQueue<V> referenceQueue; // 方便从缓存池中清除失效的软引用
    private final ValueNotFoundProvider<K, V> objectNotFoundProvider; // 当key找不到的时候的处理函数
    // 若ObjectNotFoundHandler用户不指定，会采用默认的：啥都不做
    public SoftReferenceCache() {
        this(null);
    }
    public SoftReferenceCache(ValueNotFoundProvider<K, V> handler) {
        this.referenceQueue = new ReferenceQueue<>();
        this.objectNotFoundProvider = handler != null ? handler : (k) -> null;
    }
    public V put(K key, V value) {
        // 清楚无效垃圾（也会从softReferenceMap里移除）
        clearInvalidReference();
        CacheReference<K, V> v = softReferenceMap.put(key, new CacheReference<>(key, value, referenceQueue));
        if (v == null) {
            return null;
        }
        return v.get();
    }
    /**
     * 获取，若没获取到，会使用objectNotFoundProvider提供值
     */
    public V get(K key) {
        V value = null;
        CacheReference<K, V> ref = softReferenceMap.get(key);
        if (ref == null || (ref != null && ref.get() == null)) {
            //软引用指向的对象被回收,并缓存该软引用
            value = this.objectNotFoundProvider.provideValue(key);
            if (value != null) {
                put(key, value);
            }
        }
        clearInvalidReference(); // 此时调用清理
        return value;
    }
    public boolean containsKey(K key) {
        clearInvalidReference();
        return softReferenceMap.containsKey(key);
    }
    public int size() {
        clearInvalidReference();
        return softReferenceMap.size();
    }
    public boolean isEmpty() {
        return size() == 0;
    }
    public void clear() {
        clearInvalidReference();
        softReferenceMap.clear();
    }
    public V remove(K key) {
        clearInvalidReference();
        CacheReference<K, V> v = softReferenceMap.remove(key);
        if (v == null) {
            return null;
        }
        return v.get();
    }
    /**
     * 根据已经被回收的value对应的key，是为了清除掉map里的键值对，防止本Cache的内存泄漏
     */
    private void clearInvalidReference() {
        CacheReference<K, V> cacheReference;
        while ((cacheReference = (CacheReference<K, V>) referenceQueue.poll()) != null) {
            softReferenceMap.remove(cacheReference.getKey());
        }
    }
    /**
     * 缓存应用类，继承软引用
     * 这里把key也保存起来，是因为清理的时候也得清理键值对，否则Map可能会内存泄漏的
     */
    private static class CacheReference<K, V> extends SoftReference<V> {
        private final K key;
        public CacheReference(K key, V reference, ReferenceQueue<V> queue) {
            super(reference, queue);
            this.key = key;
        }
        public K getKey() {
            return this.key;
        }
    }
    /**
     * 若缓存里木有，就交给使用者去获取（比如查库~~~）
     */
    @FunctionalInterface
    public interface ValueNotFoundProvider<K, V> {
        V provideValue(K k);
    }
}