LFU与LRU稍有不同，LFU是根据数据被访问的频率来决定去留。尽管它考虑了数据的近期使用，但它不会区分数据的首次访问和后续访问，淘汰那些访问次数最少的数据。

这种缓存策略主要用来处理以下场景：

• 数据访问模式多样化：当系统的数据访问模式差异较大，有些数据访问频率很高，而有些数据访问频率很低时，LFU算法能够有效地根据访问频率来淘汰数据，保证频繁访问的数据能够留在缓存中。
• 长时高频数据访问：对于某些数据，虽然它们不是最近被访问的，但是它们在过去的一段时间内被访问的次数很多，这种情况下，LFU算法能够保证这些数据不会被错误地淘汰。
• 缓存空间原则：当缓存空间非常有限，需要精确控制哪些数据应该被保留时，LFU算法可以提供基于频率的淘汰策略，以确保最重要的数据被保留在缓存中。
• 对于缓存数据更新频繁：LFU算法优先淘汰访问频率低的数据，因此它适合那些数据更新频繁的场景，可以确保最新的数据更容易被缓存保留。
• 缓存时长较短：LFU算法适合那些对数据持久性要求不是特别高的场景，因为一旦数据被淘汰出缓存，就有可能丢失。

LFU算法原理

利用hash表和双向链表实现，并在hash表中存储了node节点后形成一个双向链表，这样既提高了查询效率也提高了操作效率。
内存淘汰原则：

• 快速找到同一频率的节点，并同时淘汰掉最久未被使用过的数据；
• 利用hash表存储每个频率相对应的节点信息；
• 每个节点之间组成一个双向链表；

hash表中的key表示访问次数，value表示一个双向链表，链表中所有节点都是被访问过相同次数的数据节点。另外链表第三个元素freq被访问次数，这与hash表中的key值一样。当根据key找到其中一个节点时，进而知晓其访问次数和相关其它节点状态。

根据上图结构还缺少点什么，即如何根据key获取value。当然我们也可以通过hash表来存储key与节点之间的对应关系来查找。如下LFU算法的数据结构：

在Java中示例实现

创建链表缓存节点

package com.eyinfo.springlfu.lfu;

import java.io.Serializable;

public class LFUNode<K, V> implements Serializable {
   
    K key;
    V value;
    int frequency;

    public LFUNode(K key, V value) {
   
        this.key = key;
        this.value = value;
        this.frequency = 0;
    }
}

创建LFU缓存类（具体说明已在代码中标出）

package com.eyinfo.springlfu.lfu;

import lombok.Getter;

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;

public class LFUCache<K, V> {
   
    private final int capacity;
    @Getter
    private Map<K, LFUNode<K, V>> cache;
    //用于跟踪每个键的频率
    private Map<K, Integer> frequencies;

    public LFUCache(int capacity) {
   
        this.capacity = capacity;
        //利用LinkedHashMap构建LFU缓存对象
        this.cache = new LinkedHashMap<K, LFUNode<K, V>>(capacity, 0.75f, true) {
   
            protected boolean removeEldestEntry(Map.Entry<K, LFUNode<K, V>> eldest) {
   
                return size() > LFUCache.this.capacity;
            }
        };
        this.frequencies = new HashMap<>();
    }

    public void put(K key, V value) {
   
        if (cache.containsKey(key)) {