一 点睛

通过软引用使得在 JVM 进行垃圾回收的时候帮我们进行数据清理，我们可实现 SoftLRUCache，保证内存不发生溢出。

二 实战

1 SoftLRUCache

package concurrent.lrucache.strongRefercence;
import java.lang.ref.SoftReference;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
/**
* @className:SoftLRUCache
* @description: 最近最少使用缓存
* @date: 2022/4/28
* @author: cakin
*/
public class SoftLRUCache<K, V> {
    // 用于记录 key 值的顺序
    private final LinkedList<K> keyList = new LinkedList<>();
    // Value 采用软引用进行修饰
    private final Map<K, SoftReference<V>> cache = new HashMap<>();
    // cache 的最大容量
    private final int capacity;
    // 提供了一种加载数据的方式
    private final CacheLoader<K, V> cacheLoader;
    public SoftLRUCache(int capacity, CacheLoader<K, V> cacheLoader) {
        this.capacity = capacity;
        this.cacheLoader = cacheLoader;
    }
    public void put(K key, V value) {
        // 当元素数量超过容量时，将最老的数据清除
        if (keyList.size() >= capacity) {
            K eldestkey = keyList.removeFirst();  // eldest data
            cache.remove(eldestkey);
        }
        // 如果数据已经存在，则从 key 的队列中删除
        if (keyList.contains(key)) {
            keyList.remove(key);
        }
        // 将 key 存放到队尾
        keyList.addLast(key);
        cache.put(key, new SoftReference<>(value));
    }
    public V get(K key) {
        V value;
        // 先将 key 从 key list 中删除
        boolean success = keyList.remove(key);
        // 如果删除失败则表明该数据不存在
        if (!success) {
            // 通过 cacheLoader 对数据进行加载
            value = cacheLoader.load(key);
            // 通过 put 方法 cache 数据
            this.put(key, value);
        } else {
            // 如果删除成功，则从 cache 中返回数据，并且将 key 再次放到队尾
            value = cache.get(key).get();
            keyList.addLast(key);
        }
        return value;
    }
    @Override
    public String toString() {
        return this.keyList.toString();
    }
}

2 测试代码

package concurrent.lrucache.strongRefercence;
import java.util.concurrent.TimeUnit;
public class Test1 {
    public static void main(String[] args) {
        test();
    }
    private static void test() {
        SoftLRUCache<Integer, Reference> cache1 = new SoftLRUCache<>(200, key -> new Reference());
        for (Integer i = 0; i < Integer.MAX_VALUE; i++) {
            cache1.get(i);
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("The " + i + " reference stored at cache.");
        }
    }
}

三 测试结果

1 启动参数

-Xmx128M -Xms64M -XX:+PrintGCDetails

2 测试效果

内存不会溢出，内存按照锯齿状进行波动。