LRU cache简易实现

最新推荐文章于 2025-05-11 17:29:35 发布
原创 最新推荐文章于 2025-05-11 17:29:35 发布 · 552 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#LRUCACHE

本文介绍了LRU（Least Recently Used）缓存淘汰策略，解释了其基于时间局部性的思想，并通过一个示例详细阐述了使用双向链表和哨兵节点的实现方式。此外，还讨论了为何选择双向链表和哨兵节点的原因，以及提供了Java代码实现。最后，文章提到了一种更通用的版本实现，即结合HashMap以提升查询效率。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1. 什么是LRU cache?

LRU+cache
LRU(Least Recently Used)是一种淘汰策略,最近最久未使用被淘汰
与之对应的有FIFO:先进先出策略，在实时性的场景下，需要经常访问最新的数据，那么就可以使用 FIFO，使得最先进入的数据（离现在最久的,也就是旧的数据）被淘汰
cache:缓存,容量小,速度快
LRU cache,算法思想是:将最近访问的数据挪动到头部,如果下次还是访问这个数据,那么就能在靠前的位置访问到(缓存大小固定,需要淘汰最近最少访问数据)
这点其实是运用了时间局部性原理:最近一次访问的位置,下一次也很可能访问

2. 实现思路:

  1. 使用双向链表
  2. 使用哨兵节点,pre 指向尾节点,next 指向头结点
  3. 插入操作:push(1,先查找,如果有,挪动到头部2,如果没有,检查cache 是否到达大容量,如果达到了,删除尾节点,将新节点插入到头结点)
  4. 查找操作:如果没找到,返回null,如果找到,先将目标节点调整到链表头,然后返回该节点

3. 数据举例说明:

假设输入序列是 1,3,2,3,4
输入完1,链表效果是
1->哨兵->1
输入完3,效果是:(使用头插法,新的元素总是在头结点)
1 ->哨兵->3->1
输入2,链表效果:
1 ->哨兵->2->3->1
输入3:(注意cache 中已经存在3,只需要将该节点调整到头结点即可)
1 ->哨兵->3->2->1
输入4:注意,cache 大小已经达到最大缓存限制,而且　cache 不存在4,那么需要线删除尾节点(也就是1,然后将4插入到头部)
2->哨兵->4->3->2

4. java 代码实现:


import java.util.Scanner;

/**
 * @author wangwei
 * @date 2019/3/28 21:30
 * @classDescription 最近最少使用, 放在链表末尾
 * 使用双向链表:
 * 1,pop (查找元素,将目标元素放到链表头部,然后返回数据)
 * 2,push 添加元素,检查size,size如果超过最大,移除最后一个节点,将新节点插入链表头部
 */
public class LRUCache<T> {
    private int MAX_SIZE;// cache 最大容量
    private int size;
    private DoNode sentryNode;// 虚拟节点,pre 指向头节点,next 指向尾节点

    public LRUCache(int MAX_SIZE) {
        this.MAX_SIZE = MAX_SIZE;
        sentryNode = new DoNode(Integer.MIN_VALUE);
        sentryNode.next = sentryNode;
        sentryNode.pre = sentryNode;

    }

    // 查找数据,并将节点返回
    public DoNode<T> pop(T data) {
        DoNode target = search(data);
        if (null == target) {
            return null;
        }
        //将target 调整到头部
        moveExistsNodeToHead(target);
        return target;
    }

    public void push(T data) {

        DoNode lookResult = search(data);
        if (lookResult != null) {
            moveExistsNodeToHead(lookResult);
            return;
        }


        if (size >= MAX_SIZE) {
            removeLast();
        }
        // 插入新节点
        insertBeforeHead(data);
    }

    private DoNode<T> search(T data) {
        DoNode result = sentryNode.next;
        // 不要绕圈查找,如果到了哨兵还没查找到,说明缓存不存在
        while (result != null && (!result.equals(sentryNode))) {
            if (result.data.equals(data)) {
                break;
            }
            result=result.next;
        }
        return sentryNode.equals(result) ? null : result;
    }

    //将node 调整缓存中存在的节点到头部
    private void moveExistsNodeToHead(DoNode target) {
        //将target 调整到头部
        target.pre.next = target.next;
        target.next=target.pre;

        target.pre = sentryNode;
        sentryNode.next.pre=target;
        target.next=sentryNode.next;
        sentryNode.next = target;
    }

    //删除尾节点
    private void removeLast() {
        if (size <= 0) {
            throw new RuntimeException(" 不能继续删除尾节点");
        }
        sentryNode.pre = sentryNode.pre.pre;
        sentryNode.pre.next = sentryNode;
        size--;
    }

    // 头插入节点
    private void insertBeforeHead(T data) {
        DoNode node = new DoNode(data);
        node.pre = sentryNode;
        node.next = sentryNode.next;
        node.next.pre=node;
        sentryNode.next = node;

        size++;
    }

    public static void main(String[] args) {
        LRUCache<Integer> cache = new LRUCache<>(3);
        Scanner in = new Scanner(System.in);
        int [] input={1,2,3,2,3};
        for(int data:input){
            cache.push(data);
            // System.out.println("当前cache:" + cache.toString());

        }



    }


    class DoNode<T> {
        T data;
        DoNode pre;
        DoNode next;

        public DoNode(T data) {
            this.data = data;
        }


    }
}

5. 分析:

  1. 为什么使用双向链表?
    方便删除节点,以及插入节点
  2. 为什么使用哨兵
    方便快速定位头结点与尾节点(插入是在头结点,删除是在尾节点)

6另一种更通用的版本实现:

将节点定义由单独的data改为 K+DATA的

package top.forethought.linklist;

import java.util.Scanner;

/**
 * @author wangwei
 * @date 2019/3/28 21:30
 * @classDescription 最近最少使用, 放在链表末尾
 * 使用双向链表:
 * 1,pop (查找元素,将目标元素放到链表头部,然后返回数据)
 * 2,push 添加元素,检查size,size如果超过最大,移除最后一个节点,将新节点插入链表头部
 */
public class LRUCache<K,V> {
    private int MAX_SIZE;// cache 最大容量
    private int size;
    private DoNode sentryNode;// 虚拟节点,pre 指向头节点,next 指向尾节点

    public LRUCache(int MAX_SIZE) {
        this.MAX_SIZE = MAX_SIZE;
        sentryNode = new DoNode();
        sentryNode.next = sentryNode;
        sentryNode.pre = sentryNode;

    }

    // 查找数据,并将节点返回
    public DoNode<K,V> pop(K key) {
        DoNode target = search(key);
        if (null == target) {
            return null;
        }
        //将target 调整到头部
        moveExistsNodeToHead(target);
        return target;
    }

    public void push(K key,V data) {

        DoNode lookResult = search(key);
        if (lookResult != null) {
            moveExistsNodeToHead(lookResult);
            return;
        }


        if (size >= MAX_SIZE) {
            removeLast();
        }
        // 插入新节点
        insertBeforeHead(key,data);
    }

    private DoNode search(K key) {
        DoNode result = sentryNode.next;
        // 不要绕圈查找,如果到了哨兵还没查找到,说明缓存不存在
        while (result != null && (!result.equals(sentryNode))) {
            if (key.equals(result.key)) {
                break;
            }
            result = result.next;
        }
        return sentryNode.equals(result) ? null : result;
    }

    //将node 调整缓存中存在的节点到头部
    private void moveExistsNodeToHead(DoNode target) {
        //将target 调整到头部
        target.pre.next = target.next;
        target.next = target.pre;

        target.pre = sentryNode;
        sentryNode.next.pre = target;
        target.next = sentryNode.next;
        sentryNode.next = target;
    }

    //删除尾节点
    private void removeLast() {
        if (size <= 0) {
            throw new RuntimeException(" 不能继续删除尾节点");
        }
        sentryNode.pre = sentryNode.pre.pre;
        sentryNode.pre.next = sentryNode;
        size--;
    }

    // 头插入节点
    private void insertBeforeHead(K key,V data) {
        DoNode node = new DoNode(key,data);
        node.pre = sentryNode;
        node.next = sentryNode.next;
        node.next.pre = node;
        sentryNode.next = node;

        size++;
    }

    public static void main(String[] args) {
        LRUCache<Integer,Integer> cache = new LRUCache<>(3);
        Scanner in = new Scanner(System.in);
        Integer[] input = {1, 2, 3, 2, 3};
        for (Integer data : input) {
            Integer key=data-1;
            cache.push(key,data);
        }


    }


    class DoNode<K,V> {
        K key;
        V data;
        DoNode pre;
        DoNode next;

        public DoNode(K key,V data) {
            this.key=key;
            this.data = data;
        }

        public DoNode() {
        }
    }
}

其他改进思路

使用hashMap 存储key 到节点的映射,提高查询速度

Redis LRU Cache 实现
凉茶铺的博客
05-31 457
Least Recently Used，将最近最少使用的 key 从缓存中淘汰掉。以链表法为例，最近访问的 key 移动到链表头，不常访问的自然靠近链表尾，如果超过容量、个数限制，移除尾部的例如有原始数据如下，容量规定为 3如何断开节点链接如何链入头节点 参考代码一（纯手写实现） 参考代码二（借助LinkedHashMap实现）
Python functools.lru_cache 实现高速缓存及其原理 源码解析
wei_bo_cai的博客
08-08 2889
Python functools.lru_cache 实现高速缓存及其原理
设计并实现一个LRU Cache
dbbaq24022的专栏
05-09 319
一、什么是Cache 1 概念 Cache，即高速缓存，是介于CPU和内存之间的高速小容量存储器。在金字塔式存储体系中它位于自顶向下的第二层，仅次于CPU寄存器。其容量远小于内存，但速度却可以接近CPU的频率。 当CPU发出内存访问请求时，会先查看 Cache 内是否有请求数据。 如果存在（命中），则直接返回该数据； 如果不存在（失效），再去访问内存 —...
缓存（5）：常见 缓存数据淘汰算法/缓存清空策略
最新发布
учёба
05-11 1026
TinyLFU 就是其中一个优化算法，专门为了解决 LFU 上的三个问题而被设计出来的。LFU 上的三个问题如下如何减少访问频率的保存，所带来的空间开销如何减少访问记录的更新，所带来的时间开销如果提升对局部热点数据的 算法命中率解决第1个问题/第2个问题是采用了 Count–Min Sketch 算法Count-Min Sketch算法将一个hash操作，扩增为多个hash，这样原来hash冲突的概率就降低了几个等级，且当多个hash取得数据的时候，取最低值，也就是Count Min的含义所在。
LRU cache的实现
weixin_30359021的博客
06-01 121
最简单的LRU cache的实现： import java.util.LinkedHashMap; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class LruCache<K, V> extends LinkedHashMap&lt...
LRU Cache
weixin_30674525的博客
05-23 203
LRU Cache 题目链接：https://oj.leetcode.com/problems/lru-cache/ Design and implement a data structure for Least Recently Used (LRU) cache. It should support the following operations:getandset. ge...
LRU Cache 实现
weixin_42524843的博客
04-15 251
即Least Recently Used，最近最少使用 最近使用的结点放在链表的最前面，查询元素之后将元素移动到最前面，添加元素也在链表最前面添加，若超出了缓存容量，就删除链表最尾部的元素。 代码实现 比较简便的方法：通过双向链表存储顺序，并通过HashMap实现随机访问。public class LRUCache { private int capacity; private int count = 0; private HashMap<Integer, Node<Inte.
C语言实现简易Cache模拟器及LRU策略分析
4. LRU淘汰策略：LRU（Least Recently Used）是一种常用的替换策略，用于决定在Cache空间满时，哪个数据块应当被替换。LRU策略的基本思想是淘汰最长时间未被访问的数据块。实现LRU策略通常需要维护额外的记录信息，...
python cache_python自带缓存lru_cache用法及扩展(详细)
weixin_35858450的博客
03-01 2270
​本篇博客将结合python官方文档和源码详细讲述lru_cache缓存方法是怎么实现， 它与redis缓存的区别是什么， 在使用时碰上functiontools.wrap装饰器时会发生怎样的变化，以及了解它给我们提供了哪些功能然后在其基础上实现我们自制的缓存方法my_cache。1. lru_cache的使用1.1 参数详解​以下是lru_cache方法的实现，我们看出可供我们传入的参数有2个m...
Ruby内存LRU缓存实现简易指南
根据【压缩包子文件的文件名称列表】中的"in_memory_cache-master"，我们还可以推测这是一个具体的Ruby项目或者库，可能包含了以上介绍的内存LRU缓存的实现。它可能具有如下特点： - 使用Ruby语言编写。 - 实现了一...
简易实现处理器Cache行为模拟器
简易的Cache模拟器实现是一个涉及计算机体系结构和操作系统原理的重要项目，它帮助理解缓存的运作机制。在计算机系统中，Cache是位于CPU和主存之间的一种快速存储器，它具有非常小的存储容量，但是可以提供比主存更...
设计实现一个LRU Cache
weixin_33860553的博客
04-13 692
1 什么是LRU Cache 在LeetCode上有一个LRU Cache实现的题目 Design and implement a data structure for Least Recently Used (LRU) cache. It should support the following oper...
LRUCache简单实现
small_engineer的博客
06-03 945
来源于LeetCode. 146. LRU 缓存 题目要求实现一个LRUCache，我们使用get时，需要额外把该节点移动到开头；我们使用put时，如果存在该节点，我们需要把该节点删除，并且插入到开头；不存在则插入到开头，此时需要判断长度是否大于给定的capacity。并且实现这两种操作时，时间复杂度都必须为O(1);get我们使用HashMap便可以达到我们的时间复杂度，但是HashMap不是有序的，但它的子类LinkedHashMap是有序的，所以我们使用LinkedHashMap便可以达到本题的效果
LRU的cache的实现
狂奔的菜鸟
09-11 522
在网上看到一道面试题：LRU的cache设计，正好最近在学习memcached，于是很认真的研究了下这个问题最笨的实现 一个数组，所有数据堆里边，每个数据维护一个时间（上一次被使用的时间），当查找某个数据的时候，遍历数组。当cache满的时候，需要遍历找到最久没变使用的记录，然后删除。这两个遍历充分暴露了这种实现的笨。在网上搜了一下，看到大致有两种实现 1.直接利用linkedhashmap
LRUCache实现
m0_60255778的博客
10-08 235
LRUCache实现 在面试中，我们经常听到说LRU这个关键词，那么我们需要了解什么是LRU，我的理解是，LRU是一种淘汰策略，我们都知道操作系统的内存更替策略、Redis的缓存淘汰策略都有它的一个影子。那么要知其所以然，我们还得需要手工实现它，那么这里我给出一个实现是基于双端链表+哈希表的，这里并没有考虑到并发的场景，如果读者想去优化，可以给缓存加入读写锁ReentrantReadWriteLock。 public static class LRUCache { private static cl
【设计数据结构】实现一个 LRUCache
宫水三叶的刷题日记
06-17 1015
题目描述这是 LeetCode 上的 「146. LRU 缓存机制」 ，难度为 「中等」。运用你所掌握的数据结构，设计和实现一个  LRU (最近最少使用) 缓存机制 。实现 LRUCache 类：LRUCache(int capacity) 以正整数作为容量 capacity 初始化 LRU 缓存int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。void put(int key, int value) 如果关键字已经存在，
算法-LRU Cache的原理以及实现
tz的博客
07-10 1789
146. LRU 缓存 - 力扣（LeetCode）运用你所掌握的数据结构，设计和实现一个 LRU (最近最少使用) 缓存机制。LRUCache(int capacity) 以正整数作为容量 capacity 初始化 LRU 缓存int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1。void put(int key, int value) 如果关键字已经存在，则变更其数据值；如果关键字不存在，则插入该组「关键字-值」。
设计-LruCache的实现
qq_23594799的博客
07-12 383
设计类-LruCache的设计与实现设计类-LruCache的设计与实现 设计类-LruCache的设计与实现 LruCache的运用相当广泛，在加载图片等大文件时，难以离开LruCache和软引用，例如Android著名的图片加载库Glide以及网络请求库OkHttp就使用到了LruCache。在集合框架中，LinkedHashMap也可以原生的支持LruCache功能。 先看一下题目描述 运用你所掌握的数据结构，设计和实现一个 LRU (最近最少使用) 缓存机制。它应该支持以下操作： 获取数据 get
LRU Cache【理论讲解 + 代码实现】
smf12138的博客
12-01 1300
LRU是的缩写，意思是最近最少使用. 它是一种Cache替换算法.什么是Cache?狭义的Cache是指位于CPU和主存之间的快速RAM，通常它不像系统主存那样使用DRAM技术，而使用昂贵但较快速的SRAM技术. 广义上的Cache指的是位于速度相差较大的两种硬件之间，用于协调两者数据传输速度差异的结构. 除了CPU与主存之间有Cache，内存与硬盘之间也有Cache，乃至在硬盘与网络之间也有某种意义上的Cache-称为Internet临时文件或网络内容缓存等.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值