LRU LFU FIFO缓存以及代码实现

已于 2025-06-11 11:00:32 修改
阅读量1.1k 收藏 29
点赞数 27
CC 4.0 BY-SA版权
分类专栏： 【Java-EE进阶】 文章标签： 缓存 java
于 2025-06-11 10:59:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/R7chovy/article/details/148579748

目录

一.LRU缓存

1.概念

2.实现原理

3.代码示例

二.LFU缓存

1.概念

2.实现原理

3.代码示例

4.优化代码

三.FIFO缓存

1.概念

 2.实现原理

3.代码示例

LinkedHashMap 构造函数

内部类和方法重写

工作机制

总结常见缓存策略的实现

一.LRU缓存

1.概念

LRU（Least Recently Used）缓存是一种缓存淘汰策略，用来在内存有限的情况下有效管理缓存内容。LRU策略会移除最近最少使用的缓存项，从而保留较常访问的数据。它通常使用哈希表和双向链表的组合来实现，以提供O(1)的时间复杂度用于插入和访问。

2.实现原理

  1. 数据结构:

    • 哈希表：快速查找缓存项，提供O(1)的时间复杂度。
    • 双向链表：维护缓存项的访问顺序，使得尾部的节点代表最近最少使用的数据。

  2. 操作:

    • 访问：如果访问一个缓存数据，将其移动到链表的头部。
    • 插入：新数据插入链表头部。
    • 淘汰：当缓存达到容量限制时，移除链表尾部的节点。

3.代码示例

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

class LRUCache<K,V> {
    class Node<K,V>{
        K key;
        V value;
        Node<K,V> prev;
        Node<K,V> next;
        public Node() {}
        public Node(K key,V value) {
            this.key=key;
            this.value=value;
        }
    }
    private Map<K,Node<K,V>> hash=new HashMap<>();
    int capacity;
    private Node<K,V> head,tail;
    public LRUCache(int capacity) {
        this.capacity=capacity;
        head=new Node();
        tail=new Node();
        head.next=tail;
        tail.prev=head;
    }
    public V get(K key) {
        Node<K,V> node=hash.get(key);
        if(node==null) {
            return null;
        }
        moveToHead(node);
        return node.value;
    }
    public void put(K key,V value) {
        Node<K,V> node=hash.get(key);
        if(node==null) {
            Node<K,V> newNode=new Node<K,V>(key,value);
            hash.put(key,newNode);
            addToHead(newNode);
            if(hash.size()>capacity) {
                //此时进行删除
                Node<K,V> temp=removeTail();
                hash.remove(temp.key);
            }
        } else {
            node.value=value;
            moveToHead(node);
        }
    }
    public Node<K,V> removeTail() {
        Node<K,V> ans=tail.prev;
        removeNode(ans);
        return ans;
    }
    public void removeNode(Node<K,V> node) {
        node.prev.next=node.next;
        node.next.prev=node.prev;
    }
    public void addToHead(Node<K,V> node) {
        node.prev = head;
        node.next = head.next;
        head.next.prev = node;
        head.next = node;
    }
    public void moveToHead(Node<K,V> node) {
        removeNode(node);
        addToHead(node);
    }
}

注：流程就是当我们插入到一个数据的时候将其放到双向链表头部位置，这里的head和tail是用来指向双向链表的头结点和尾结点的，俗称为哨兵位。对于已经存在节点，我们无论是查询还是修改值，都会影响这个节点使用的时间，所以每次在使用完之后将其移动到头节点的位置，对于移动节点的时候，这里做的是将其节点删除，在进行插入。所以每次删除节点的时候，tail所指向的节点就是我们要删除的节点。

二.LFU缓存

1.概念

LFU (Least Frequently Used) 缓存是一种缓存淘汰策略，用于在有限的内存中有效管理缓存内容。LFU缓存会移除使用频率最低的缓存项。当缓存容量达到限制时，频率最低的项将被移除。

2.实现原理

  1. 数据结构:

    • 哈希表：用于存储键到节点的映射，提供O(1)时间复杂度的查找。
    • 优先队列：用来根据使用频率排序节点，频率最低的节点在队列顶部，提供O(log N)的插入和删除操作。

  2. 操作:

    • 访问：每次访问时增加项的频率，并重新调整优先队列的顺序。
    • 插入：如果新数据插入并且达到容量上限，将移除优先队列中最低频率的节点。

3.代码示例

import java.util.HashMap;
import java.util.Map;
import java.util.PriorityQueue;

public class LFUCache<K,V> {
    class Node<K,V>{
        K key;
        V value;
        int  frequency;
        public Node() {}
        public Node(K key,V value) {
            this.key=key;
            this.value=value;
            this.frequency=1;
        }
    }
    private int capacity;
    private Map<K,Node<K,V>> hash=new HashMap<>();
    private PriorityQueue<Node<K,V>> queue;
    public LFUCache(int capacity) {
        this.capacity=capacity;
        queue=new PriorityQueue<>((node1,node2)->node1.frequency-node2.frequency);
    }
    public void put(K key,V value) {
        if(capacity==0) {
            return;
        }
       Node<K,V> node=hash.get(key);
       if(node==null) {
           Node<K,V> newNode=new Node<>(key,value);
           hash.put(key,newNode);
           if(hash.size()>capacity) {
               Node<K,V> temp = queue.poll();
               hash.remove(temp.key);
           }
           queue.offer(newNode);
       } else {
           node.value=value;
           node.frequency++;
           queue.remove(node);
           queue.offer(node);
       }
    }
    public V get(K key) {
        Node<K,V> node=hash.get(key);
        if(node==null) {
            return null;
        }
        node.frequency++;
        queue.remove(node);
        queue.offer(node);
        return node.value;
    }
}

 注：这里的频率表示有点简单。在插入节点的时候，先将节点插入到hash中，然后再进行判断缓存大小是否大于容量，大于容量再将堆顶的元素删除。再元素插入到队列中。这时候发现一个问题，我们初始插入的节点频率为1，如果队列中频率都新节点大，那不是要删除新节点吗?

但是我们一想，如果新插入的节点就直接删除的话，那插入还有什么意思。

测试代码

 public static void main(String[] args) {
        LFUCache cache = new LFUCache(2);
        cache.put(1, 1);
        cache.put(2, 2);
        System.out.println(cache.get(1)); // 输出 1
        cache.put(3, 3); // 淘汰频率最低的键 2
        System.out.println(cache.get(2)); // 输出 null
        System.out.println(cache.get(3)); // 输出 3
        cache.put(4, 4); // 淘汰频率最低的键 1
        System.out.println(cache.get(1)); // 输出 null
        System.out.println(cache.get(3)); // 输出 3
        System.out.println(cache.get(4)); // 输出 null
    }

 

在调试的时候断点直接打在cache.put(4,4)这一行，队列里的元素频率都比4这个节点频率大。 但是我们肯定不想将4直接删除，所以要进行优化缓存策略。

4.优化代码


    import java.util.*;
    public class LFUCacheOptimized {
        class Node {
            int key, value, frequency;
            Node prev, next;

            public Node(int key, int value) {
                this.key = key;
                this.value = value;
                this.frequency = 1;
            }
        }

        class FrequencyList {
            Node head, tail;

            public FrequencyList() {
                head = new Node(-1, -1);
                tail = new Node(-1, -1);
                head.next = tail;
                tail.prev = head;
            }

            public void insert(Node node) {
                node.next = head.next;
                node.prev = head;
                head.next.prev = node;
                head.next = node;
            }

            public void remove(Node node) {
                node.prev.next = node.next;
                node.next.prev = node.prev;
            }

            public Node removeLast() {
                if (tail.prev == head) return null;
                Node node = tail.prev;
                remove(node);
                return node;
            }
        }

        private final int capacity;
        private Map<Integer, Node> cache;
        private Map<Integer, FrequencyList> frequencyMap;
        private int minFrequency;

        public LFUCacheOptimized(int capacity) {
            this.capacity = capacity;
            cache = new HashMap<>();
            frequencyMap = new HashMap<>();
            this.minFrequency = 0;
        }

        public int get(int key) {
            Node node = cache.get(key);
            if (node == null) return -1;
            updateFrequency(node);
            return node.value;
        }

        public void put(int key, int value) {
            if (capacity == 0) return;
            Node node = cache.get(key);
            if (node == null) {
                if (cache.size() == capacity) {
                    FrequencyList list = frequencyMap.get(minFrequency);
                    Node removedNode = list.removeLast();
                    cache.remove(removedNode.key);
                }
                node = new Node(key, value);
                cache.put(key, node);
                minFrequency = 1;
                frequencyMap.computeIfAbsent(1, k -> new FrequencyList()).insert(node);
            } else {
                node.value = value;
                updateFrequency(node);
            }
        }

        private void updateFrequency(Node node) {
            int freq = node.frequency;
            FrequencyList list = frequencyMap.get(freq);
            list.remove(node);
            if (freq == minFrequency && list.head.next == list.tail) {
                minFrequency++;
            }
            node.frequency++;
            frequencyMap.computeIfAbsent(node.frequency, k -> new FrequencyList()).insert(node);
        }

        public static void main(String[] args) {
            LFUCacheOptimized cache = new LFUCacheOptimized(2);
            cache.put(1, 1);
            cache.put(2, 2);
            System.out.println(cache.get(1)); // 输出 1
            cache.put(3, 3); // 淘汰频率最低的键 2
            System.out.println(cache.get(2)); // 输出 -1
            System.out.println(cache.get(3)); // 输出 3
            cache.put(4, 4); // 淘汰频率最低的键 1
            System.out.println(cache.get(1)); // 输出 -1
            System.out.println(cache.get(3)); // 输出 3
            System.out.println(cache.get(4)); // 输出 4
        }
    }

 解析：

 frequencyMap.computeIfAbsent(node.frequency, k -> new FrequencyList()).insert(node);

当使用frequencyMap.computeIfAbsent(node.frequency, k -> new FrequencyList())时，如果node.frequency已经存在于frequencyMap中，computeIfAbsent方法将直接返回与node.frequency关联的FrequencyList实例，而不是执行提供的映射函数k -> new FrequencyList()。

在这种情况下，频率存在，即Map不会为该频率创建新的FrequencyList对象，直接在现有的FrequencyList中插入节点。

 注：如果涉及多线程的场景下，使用ConcurrentHashMap更为妥当。

三.FIFO缓存

1.概念

FIFO（First-In-First-Out）缓存是一种简单但有效的缓存淘汰策略，当缓存达到容量时淘汰最早插入的缓存项。

 2.实现原理

  1. 数据结构:
    • LinkedHashMap：保持插入顺序并在达到容量上限时自动删除最早的缓存项。
  2. 操作:
    • 插入: 新数据插入时按顺序放置。
    • 淘汰: 当容量达到限制时，自动移除链表中的最早元素。

3.代码示例


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

     class FIFOCache<K, V> {
        private final int capacity;
        private final LinkedHashMap<K, V> cache;

        public FIFOCache(int capacity) {
            this.capacity = capacity;
            // LinkedHashMap构造方法的第三个参数为false，表示根据插入顺序排序
            this.cache = new LinkedHashMap<K, V>(capacity, 0.75f, false) {
                @Override
                protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
                    // 当缓存大小超过设置的容量时，移除最早插入的元素
                    return size() > FIFOCache.this.capacity;
                }
            };
        }

        // 从缓存获取数据
        public V get(K key) {
            return cache.get(key);
        }

        // 向缓存插入数据
        public void put(K key, V value) {
            cache.put(key, value);
        }

        // 测试FIFO缓存功能
        public static void main(String[] args) {
            FIFOCache<String, Integer> fifoCache = new FIFOCache<>(2);
            fifoCache.put("A", 1);
            fifoCache.put("B", 2);
            System.out.println(fifoCache.get("A")); // 输出 1

            fifoCache.put("C", 3); // 淘汰最早插入的键 A

            System.out.println(fifoCache.get("A")); // 输出 null，A 已被淘汰
            System.out.println(fifoCache.get("B")); // 输出 2，B 仍然存在

            fifoCache.put("D", 4); // 淘汰最早插入的键 B

            System.out.println(fifoCache.get("B")); // 输出 null，B 已被淘汰
            System.out.println(fifoCache.get("C")); // 输出 3，C 仍然存在
            System.out.println(fifoCache.get("D")); // 输出 4，D 已插入
        }
    }

LinkedHashMap 构造函数

复制

new LinkedHashMap<K, V>(capacity, 0.75f, false)
  • 参数解析：
    • capacity：表示构造 LinkedHashMap 的初始容量，实际容量可能会根据负载因子和存入的元素动态增大。
    • 0.75f：这是装载因子（load factor），用于控制LinkedHashMap何时进行扩容。在目前的应用中，不会直接影响缓存策略。
    • false：指示LinkedHashMap根据插入顺序存储条目，而不是访问顺序。传入false确保访问顺序不更改原始的插入顺序，从而实现FIFO逻辑。

内部类和方法重写

复制

@Override
protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
    return size() > FIFOCache.this.capacity;
}
  • 重写方法 removeEldestEntry：
    • 在LinkedHashMap中，removeEldestEntry是被用于判断在每次插入新条目时，是否需要移除最老的条目的方法。
    • 条件：size() > FIFOCache.this.capacity，检查当前缓存大小是否超过指定容量。
    • 如果缓存大小超过设定容量，将移除最早插入的元素（最终以FIFO顺序删除）。

工作机制

  • 插入条目：每当一个新条目插入LinkedHashMap时，系统将调用removeEldestEntry方法来决定是否移除旧条目。
  • FIFO策略实现：因为LinkedHashMap被配置为按插入顺序存储，并在超出容量时移除最老的条目，因此实现了FIFO策略。

总结常见缓存策略的实现

  1. LRU（Least Recently Used）缓存：

    • 使用双向链表和哈希表实现。
    • 淘汰最近最少使用的数据。

  2. LFU（Least Frequently Used）缓存：

    • 使用优先队列和哈希表实现。
    • 淘汰使用频率最低的数据。

  3. FIFO（First-In-First-Out）缓存：

    • 使用LinkedHashMap的特殊配置实现。
    • 淘汰最早插入的数据。
LRU缓存（LRUCache）
爱写bug的王六六
02-27 5559
146. LRU 缓存 题目描述： 请你设计并实现一个满足 LRU (最近最少使用) 缓存 约束的数据结构。 实现 LRUCache 类： LRUCache(int capacity) 以 正整数 作为容量 capacity 初始化 LRU 缓存（cache） int get(int key)如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。 void put(int key, int value) 如果关键字 key 已经存在，则变更其数据值 value ； 如果不存在，则向缓存
缓存淘汰策略：LRU、LFU、FIFO 算法原理
Java Punk
02-18 6963
LRU、LFU、FIFO、Two queues（2Q）算法原理
LRU缓存
weixin_43624024的博客
10-16 3014
一、什么是LRU算法 LRU，Least Recently Used算法，即一种缓存淘汰策略。 计算机的缓存容量有限，若缓存满了则需要删除一些内容，给新的缓存腾出空间，但问题是要删除哪些内容呢？当然是把用的少的缓存删掉，把最有用的数据继续保留以便于继续使用。那么如何判定哪些数据是有用的呢？ 缓存淘汰的策略有很多，而LRU则是一种较为简单常用的算法，LRU判定最近使用过的数据为有用的，很久都没...
LRU 缓存
dotJunz的博客
08-22 782
LRU 缓存 用自带的 LinkedHashMap 实现 自己实现哈希链表
缓存算法之FIFO、LRU、LFU的Python实现
ybn6775的博客
07-17 2657
                                    缓存算法之FIFO、LRU、LFU的Python实现         早期计算机内存有限，程序的运行与加载依赖页面置换算法， 其目的是将部分数据缓存在内存中， 在使用的时候就不必去磁盘上加载，这样可以提高运行的效率，虽然现在计算机的内存控件已经得到了很大的提升， 但是这种缓存策略一直被沿用， 尤其对于需要访问IO以及数据库等...
C++实现的LRU、LFU、FIFO缓存策略详解
本文将详细介绍三种常见的缓存替换算法：最近最少使用（LRU）、最不经常使用（LFU）以及先进先出（FIFO），并提供相应的C++实现。我们将重点关注这些算法的概念、应用场景以及它们在C++中的实现方式。 ### LRU缓存...
Java置换算法的代码实现示例：LRU、LFU和FIFO的代码实现与性能优化
常见的置换算法包括LRU（最近最少使用）、LFU（最近最不常使用）和FIFO（先进先出）。 不同置换算法的性能和适用场景不同。LRU算法适用于访问模式具有时间局部性的场景，而LFU算法适用于访问模式具有频率局部性的...
基于Java的轻量级缓存组件，实现LRU、LFU、FIFO等缓存清除算法
衡与墨的博客
06-29 548
该组件使用简单、可靠 类图如下： 例如： DawnSimpleCache dawnSimpleCache = new DawnSimpleCache( "testCache", 2, DawnSimpleCache.LRU, 1F); // 设置缓存数据 dawnSimpleCache.setCache("test1", "xxx", 200, TimeUnit.SECONDS); // 从缓存获取数据
LFU缓存
04-13 186
https://leetcode-cn.com/problems/lfu-cache/description/ 缓存的实现可以采取多种策略，不同策略优点的评估就是“命中率”。好的策略可以实现较高的命中率。常用的策略如：LRU（最近最少使用）、LFU（最不频繁使用）。这两种策略都可以在O（1）时间内实现get和put。关于LRU，在 http://www.cnblogs.com/weiyi...
一、LRU缓存
最新发布
qq_53280985的博客
12-15 1514
LRU是Least Recently Used 的缩写，意为“最近最少使用”。它是一种常见的缓存淘汰策略，用于在缓存容量有限时，决定哪些数据需要被删除以腾出空间。LRU 缓存的基本原则是：①优先保留最近被访问的数据，因为这些数据在近期被再次访问的概率更高。②淘汰最近最少使用的数据，因为它们被再次访问的可能性较小。
主存写cache冲突（访问不命中）时替换算法
C++
10-12 1613
缓存算法是指令的一个明细表，用于决定缓存系统中哪些数据应该被删去。 常见类型包括LFU、LRU、ARC、FIFO、MRU。 最不经常使用算法（LFU）： 这个缓存算法使用一个计数器来记录条目被访问的频率。通过使用LFU缓存算法，最低访问数的条目首先被移除。这个方法并不经常...
LeetCode 146：LRU 缓存
机械工程跑路哥
07-20 1102
因为在删除节点时，使用removeFirst()删除链表头部也就是最长时间未使用的节点，然后需要再根据该方法返回的这个节点的key，去删除hashmap中对应的键值对；而事实上，在一个时间段内，只需要访问一小部分数据即可正常运行，这就导致内存中驻留了大量用不到的数据；因为删除链表时，双向链表的前驱操作可以保证时间复杂度为O(1)，而单向链表的删除要从头遍历直到找到节点，时间复杂度为O(n)；LRU的全称是LeastRecentlyUsed，也就是说我们认为最近使用过的数据应该是是「有用的」，........
数据结构设计之LRU缓存
weixin_41804570的博客
06-29 388
 146. LRU 缓存【中等】，链接: linkJava
LRU缓存原理
weixin_34272308的博客
10-29 179
LRU(Least Recently Used)LRU是近期最少使用的算法，它的核心思想是当缓存满时，会优先淘汰那些近期最少使用的缓存对象。 采用LRU算法的缓存有两种：LrhCache和DisLruCache，分别用于实现内存缓存和硬盘缓存，其核心思想都是LRU缓存算法。 1.LruCache的介绍 LruCache是个泛型类，主要算法原理是把最近使用的对象用强引用（即我们平常使用的对...
实现 LRU 缓存算法
cr7258的博客
05-18 4547
1 LRU 缓存介绍 LRU 算法全称是最近最少使用算法（Least Recently Use），是一种简单的缓存策略。顾名思义，LRU 算法会选出最近最少使用的数据进行淘汰。 那么什么是缓存呢？缓存专业点可以叫一种提高数据读取性能的技术，可以有效解决存储器性能和容量的矛盾，是一种空间换时间的设计思想，比如我们常见的内存是硬盘的缓存，Cache 是内存的缓存，浏览器本地存储是网络访问的缓存...... LRU 有许多应用场景，例如： 操作系统底层的内存管理。 缓存服务，例如 Redis，当数据满的时候就要
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值