Java 自定义实现 LRU 缓存算法

最新推荐文章于 2022-07-27 10:19:57 发布
最新推荐文章于 2022-07-27 10:19:57 发布
阅读量640 收藏 1
点赞数 1
文章标签： java 缓存 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46589658/article/details/122401275
版权

这里写目录标题

Java 自定义实现 LRU（最近最少使用） 缓存算法

方式一基于LinkedHashMap实现LRU缓存算法

LinkedHashMap

  1. LinkedHashMap继承自HashMap，内部提供了一个removeEldestEntry方法，该方法正是实现LRU策略的关键所在， 且HashMap内部专门为LinkedHashMap提供了3个专用回调方法，afterNodeAccess、 afterNodeInsertion、afterNodeRemoval，这3个方法的字面意思非常容易理解，就是节点访问后、节点插入后、节点删除后 分别执行的行为。基于以上行为LinkedHashMap就可以实现一个LRUCache的功能了。
  2. 关于LinkedHashMap的eldest：eldest字面意思为最老的，LinkedHashMap中有个叫做accessOrder的字 段，当accessOrder为true时表示LinkedHashMap内部节点按照访问次数排序，最老的节点也就是访问最少的节点。当 accessOrder为false时表示LinkedHashMap内部节点按照插入顺序排序，最老的节点也就是最早插入的节点，该值默认为 false。

代码实现

class LRUCache extends LinkedHashMap<Integer,Integer>{

    private int capacity;

    public LRUCache(int capacity) {
        //初始化LinkedHashMap
        super(capacity,0.75F,true);
        this.capacity = capacity;
    }

    public int get(int key) {
        return super.getOrDefault(key,-1);
    }

    public void put(int key, int value) {
        super.put(key,value);
    }
    @Override
    protected boolean removeEldestEntry(Map.Entry<Integer, Integer> eldest) {
        return size() > capacity;
    }
}

方式二自定义双向链表 + 哈希表实现

实现思路

  1. 通过哈希表辅以双向链表实现，我们用一个哈希表和一个双向链表维护所有在缓存中的键值对。
  2. 双向链表按照被使用的顺序存储了这些键值对，靠近头部的键值对是最近使用的，而靠近尾部的键值对是最久未使用的
  3. 哈希表即为普通的哈希映射（HashMap），通过缓存数据的键映射到其在双向链表中的位置

代码实现

class LRUCache {
    //自定义双向链表
    class LinkedNode {
        int key;
        int value;
        LinkedNode prev;//前驱结点
        LinkedNode next;//后继结点
        public LinkedNode() {};
        public LinkedNode(int _key, int _value) {key = _key; value = _value;}
    }

    //哈希表
    private Map<Integer, LinkedNode> cache = new HashMap<>();
    private int size;
    private int capacity;
    //头结点和尾结点
    private LinkedNode head, tail;

    //构造器，初始化容量
    public LRUCache(int capacity) {
        this.size = 0;
        this.capacity = capacity;
        //使用伪头结点和伪为节点
        head = new LinkedNode();
        tail = new LinkedNode();
        head.next = tail;
        tail.prev = head;
    }

    public int get(int key){
        //从hash表中根据key获取双向链表结点位置达到O（1）的时间复杂度
        LinkedNode linkedNode = cache.get(key);
        //如果hash表中没有值，那么返回默认值-1
        if (linkedNode == null) return -1;
        //如果存在,把这个值移动到双向链表的头部
        //链表的头部记录了最近使用过的结点，尾部记录了最近不常被使用的结点
        moveToHead(linkedNode);
        return linkedNode.value;
    }

    public void put(int key, int value) {
        LinkedNode node = cache.get(key);
        if (node == null) {
            // 如果 key 不存在，创建一个新的节点
            LinkedNode newNode = new LinkedNode(key, value);
            // 添加进哈希表
            cache.put(key, newNode);
            // 添加至双向链表的头部
            addToHead(newNode);
            size++;
            if (size > capacity) {
                // 如果超出容量，删除双向链表的尾部节点
                LinkedNode tail = removeTail();
                // 删除哈希表中对应的项
                cache.remove(tail.key);
                size--;
            }
        }
        else {
            // 如果 key 存在，先通过哈希表定位，再修改 value，并移到头部
            node.value = value;
            moveToHead(node);
        }
    }

    //把节点移动到头部
    private void moveToHead(LinkedNode node){
        //先删除，后添加
        removeNode(node);
        addToHead(node);
    }
    //添加结点到链表头部
    private void addToHead(LinkedNode node){
        //伪头结点的后继结点就是当前要插入的结点
        node.prev = head;
        node.next = head.next;
        head.next.prev = node;
        head.next = node;
    }
    //删除结点
    private void removeNode(LinkedNode node){
        LinkedNode prev = node.prev;
        prev.next = node.next;
        node.next.prev = prev;
    }
    //删除尾部结点
    private LinkedNode removeTail(){
        //因为使用伪头尾结点的原因，伪尾结点的前驱结点就是实际元素结点的尾部
        LinkedNode prev = tail.prev;
        removeNode(prev);
        return prev;
    }
}

方式三借助ReadWriteLock（读写锁）+ 双向链表 + 哈希表实现线程安全的LRU缓存算法

实现思路

  1. 借助ReadWriteLock（读写锁）+ 双向链表 + 哈希表实现线程安全的LRU缓存算法，当get的时候加上读锁，当put的时候加上写锁

代码实现

class LRUCache {
    //读写锁对象
    private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();

    //自定义双向链表
    class LinkedNode {
        int key;
        int value;
        LinkedNode prev;//前驱结点
        LinkedNode next;//后继结点
        public LinkedNode() {};
        public LinkedNode(int _key, int _value) {key = _key; value = _value;}
    }

    //哈希表
    private Map<Integer, LinkedNode> cache = new HashMap<>();
    private int size;
    private int capacity;
    //头结点和尾结点
    private LinkedNode head, tail;
    //构造器，初始化容量
    public LRUCache(int capacity) {
        this.size = 0;
        this.capacity = capacity;
        //使用伪头结点和伪为节点
        head = new LinkedNode();
        tail = new LinkedNode();
        head.next = tail;
        tail.prev = head;
    }

    //当进行get时加上读锁
    public int get(int key){
        //上读锁
        readWriteLock.readLock().lock();
        try {
            //从hash表中根据key获取双向链表结点位置达到O（1）的时间复杂度
            LinkedNode linkedNode = cache.get(key);
            //如果hash表中没有值，那么返回默认值-1
            if (linkedNode == null) return -1;
            //如果存在,把这个值移动到双向链表的头部
            //链表的头部记录了最近使用过的结点，尾部记录了最近不常被使用的结点
            moveToHead(linkedNode);
            return linkedNode.value;
        }finally {
            //释放读锁
            readWriteLock.readLock().unlock();
        }
    }

    //当进行put操作时加上写锁
    public void put(int key, int value) {
        //上写锁
        readWriteLock.writeLock().lock();
        try {
            LinkedNode node = cache.get(key);
            if (node == null) {
                // 如果 key 不存在，创建一个新的节点
                LinkedNode newNode = new LinkedNode(key, value);
                // 添加进哈希表
                cache.put(key, newNode);
                // 添加至双向链表的头部
                addToHead(newNode);
                ++size;
                if (size > capacity) {
                    // 如果超出容量，删除双向链表的尾部节点
                    LinkedNode tail = removeTail();
                    // 删除哈希表中对应的项
                    cache.remove(tail.key);
                    --size;
                }
            }
            else {
                // 如果 key 存在，先通过哈希表定位，再修改 value，并移到头部
                node.value = value;
                moveToHead(node);
            }
        }finally {
            readWriteLock.writeLock().unlock();
        }
    }

    //把节点移动到头部
    private void moveToHead(LinkedNode node){
        //先删除，后添加
        removeNode(node);
        addToHead(node);
    }
    //添加结点到链表头部
    private void addToHead(LinkedNode node){
        //伪头结点的后继结点就是当前要插入的结点
        node.prev = head;
        node.next = head.next;
        head.next.prev = node;
        head.next = node;
    }
    //删除结点
    private void removeNode(LinkedNode node){
        LinkedNode prev = node.prev;
        prev.next = node.next;
        node.next.prev = prev;
    }
    //删除尾部结点
    private LinkedNode removeTail(){
        //因为使用伪头尾结点的原因，伪尾结点的前驱结点就是实际元素结点的尾部
        LinkedNode prev = tail.prev;
        removeNode(prev);
        return prev;
    }
}

最后由于个人技术水平有限，本文难免有不足的地方，请各位给予指正。

搬砖技术员
关注
LRU算法（使用自定义双向链表实现）
students__的博客
07-21 2060
LRU算法：最近最少使用算法 核心思想：淘汰掉最近访问次数最少的字块 举一个例子：假设缓存有4个字块 1 2 3 4 此时该四个字块被访问并加载到缓存中，假设此时，cpu第二次访问，访问到3这个字块，LRU算法会把3这个字块置换到序列的最前面，此时，序列顺序变成 3 1 2 4，假设此时，cpu第三次访问，访问了内存当中的第5个字块，但...
Android 中okhttp自定义Interceptor（缓存拦截器）
08-31
当缓存大小超过这个限制时，OkHttp会自动使用LRU算法删除旧的缓存条目。 总结来说，通过自定义Interceptor，我们能够在Android应用中实现对OkHttp的精细控制，特别是对于缓存策略的定制。这样，即使服务器没有提供...
LRU缓存算法（Java实现）
Hacker_Jp 博客
03-16 390
LRU是Least Recently Used的缩写，即最近最久未使用，常用于页面置换算法，是为虚拟页式存储管理服务的。 LRU算法的提出，是基于这样一个事实：在前面几条指令中使用频繁的页面很可能在后面的几条指令中频繁使用。反过来说，已经很久没有使用的页面很可能在未来较长的一段时间内不会被用到。 设计并实现了一个最近最少使用（LRU）缓存的数据结构，它应该支持以下操作：get和set。 ge...
自定义实现 LRU 容器-Java版
phaeton_lai的博客
03-29 301
最近在学习算法，遇到一个实现 LRU 的题目，自己花了一天的时间完成了代码实现基本功能测试测试，这里和大家分享一下。 1. 功能介绍 该实现支持新增及修改操作时的数据置顶，需要注意的是，当删除记录时，如果要删除的记录在活跃链表中，记录的删除动作不会促使非活跃数据的晋升。 举例：如果 cache 中一共有10条数据，活跃链表的长度为5，链表中记录的数据为1~5，现将4删除，删除之后不会使非...
java实现LRU缓存
me34293的博客
03-27 119
java实现LRU缓存 LRU缓存： least recent used：最久不使用的淘汰； 特点： 加入或者更新将其移到最前面； 缓存不够了需要删除最久未使用的。 实现结构： 双链表 定义双链表节点： /** * 双链表的节点 */ public class Node { Object key; Object value; Node pre; Node next; public Node(Object key, Object value) {
Java实现LRU算法.zip
11-13
通过以上代码，我们已经构建了一个简单的LRU缓存系统。在实际应用中，LRU算法不仅可以用于操作系统中的页面替换，还可以应用于数据库查询缓存、编程语言的内存管理（如Java的SoftReference和WeakReference）以及Web...
Java和Android的LRU缓存及实现原理
01-20
在Java和Android中，LRU缓存的实现主要依赖于`LinkedHashMap`类。 一、LRUCache在Android中的应用 在Android中，`LRUCache`是专门为Android平台设计的一个简单的LRU缓存实现。它内部使用了`LinkedHashMap`，并且...
实现 LRU 算法，和 Caffeine 和 Redis 中的缓存淘汰策略.docx
07-10
LRU (Least Recently Used) 算法是一种常用的缓存淘汰策略，它的核心思想是优先淘汰...在 Java 中，`LinkedHashMap` 是实现 LRU 缓存的一种高效方式，但也需要理解其内部机制，以便在面试或特定场景下进行自定义实现。
自定义LRU缓存
lucyLee的博客
12-19 260
1. 絮絮叨叨 在计算机领域，LRU算法的应用非常多，最常见的就是LRU缓存 LRU：Least Recently USed，最近最少使用 英文和中文存在差异，如果只看中文，貌似RLU更合适 ???? 基于LRU算法的缓存系统，可以在达到缓存容量上限时，清理最近最少使用的数据，为新的数据的插入腾出空间 leetcode上，也有对应的LRU缓存算法题：146. LRU 缓存机制 牛客上，蚂蚁金服的面试题库，LRU缓存也赫然在列 题目要求大概如下： 设计和实现一个LRU算法的缓存数据结构。需要实现两个操作：
Java实现LRU缓存算法
木子雷的博客
03-20 346
最困难的事情就是认识自己！ 个人博客，欢迎访问！ 前言： 什么是LRU算法：LRU是Least Recently Used的缩写，即最近最久未使用，是一种操作系统中常用的页面置换算法。 应用场景： 知道了什么是LRU后，我们再来聊下它的使用场景；在工作中，对于Redis我们一定是比较熟悉的，它是一个内存数据库；因为它是内存数据库，并且内存的空间是有限的，如果Redis中数据量很...
算法---Lru缓存（Java）
男儿不展风云志，空有天生八尺躯
03-23 734
题目： 设计和构建一个“最近最少使用”缓存，该缓存会删除最近最少使用的项目。缓存应该从键映射到值(允许你插入和检索特定键对应的值)，并在初始化时指定最大容量。当缓存被填满时，它应该删除最近最少使用的项目。 它应该支持以下操作： 获取数据 get 和 写入数据 put 。 获取数据 get(key) - 如果密钥 (key) 存在于缓存中，则获取密钥的值（总是正数），否则返回 -1。 写入数据 put(key, value) - 如果密钥不存在，则写入其数据值。当缓存容量达到上限时，它应该在写入新数据之前删除
Java实现LRU缓存
azbh111的博客
06-13 210
Java实现LRU算法
自定义(java)的缓存实现_Java自定义LRU缓存实现
weixin_34723270的博客
03-01 169
自定义LRU缓存实现Cache缓存接口public interface Cache {/*** 缓存ID* @return*/String getId();Object get(String key);void put(String key,Object value);void clear();void remove(String key);int size();}LRUCacheImplpubl...
Java自定义缓存器
qq_41570752的博客
07-27 510
提供了基本的缓存增删、过期等方法，使用于单机情况，测试使用。
JAVA 实现自定义的缓存实现
weixin_34015336的博客
01-29 629
2019独角兽企业重金招聘Python工程师标准>>> ...
缓存淘汰算法LRU及JAVA实现
Think In JAVA—Max
09-20 1121
一、基本概念 命中：访问缓存是通过key get到对应value 回源： miss了，未命中导致回读源数据 淘汰：缓存满了，那么就会按照某一种策略，把缓存中的旧对象踢出，而把新的对象加入缓存池。（只有5个存储单元，来了第6个元素。则考虑谁出队） 淘汰策略：即缓存算法，决定到底应该踢出哪些对象 缓存污染：不常用的数据加入进缓存，降低了缓存效率的现象 二、缓存淘汰算法LRU LRU（Le...
Java实现LRU缓存深度解析
在Java中，实现LRU缓存有多种方式，其中最常见的就是利用`LinkedHashMap`类。 `LinkedHashMap`是Java `Map`接口的一个实现，它在内部维护了一个双向链表和一个哈希表。这个类提供了两种排序方式：插入顺序和访问...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值