LRUCache详解

最新推荐文章于 2024-05-11 09:00:00 发布
最新推荐文章于 2024-05-11 09:00:00 发布
阅读量7.8k 收藏 15
点赞数 2
分类专栏： # 数据结构 文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_56444564/article/details/128429226
版权

1.概念

LRU是Least Recently Used的缩写，意思是最近最少使用，它是一种Cache替换算法。
Cache的容量有限，因此当Cache的容量用完后，而又有新的内容需要添加进来时， 就需要挑选并舍弃原有的部分内容，从而腾出空间来放新内容。LRU Cache 的替换原则就是将最近最少使用的内容替换掉。其实，LRU译成最久未使用会更形象， 因为该算法每次替换掉的就是一段时间内最久没有使用过的内容。
 

2.LRUCache的实现原理

实现LRU Cache的方法和思路很多，但是要保持高效实现O(1)的put和get，那么使用双向链表和哈希表的搭配是最高效和经典的。

使用双向链表是因为双向链表可以实现任意位置O(1)的插入和删除，

使用哈希表是因为哈希表的增删查改也是O(1)。

package test;

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

class Node {
    public int key;
    public int val;

    public Node prev;

    public Node next;

    public Node() {

    }

    public Node(int key, int val) {
        this.key = key;
        this.val = val;
    }

    @Override
    public String toString() {
        return "Node{" +
                "key=" + key +
                ", val=" + val +
                '}';
    }
}

public class MyLRUCache {
    public Node head;
    public Node tail;

    public int usedsize;
    public Map<Integer, Node> cache;
    public int capacity;

    public MyLRUCache(int capacity) {
        this.head = new Node();
        this.tail = new Node();
        head.next = tail;
        tail.prev = head;
        cache = new HashMap<>();
        this.capacity = capacity;
    }

    //插入元素
    public void put(int key, int val) {
        Node node = cache.get(key);
        if (node == null) {
            Node newnode = new Node(key, val);
            cache.put(key, newnode);
            addToTail(newnode);
            usedsize++;
            //检查当前双向链表的有效数据个数 是不是超过了capacity
            if (usedsize > capacity) {
                Node removeNode = removeHead();
                cache.remove(removeNode.key);
                usedsize--;
            }
            printNodes("put");
        } else {
            //更新val的值，其实没必要
            node.val = val;
            moveTotail(node);
        }
    }

    //删除指定节点
    public void removeNode(Node node) {
        node.prev.next = node.next;
        node.next.prev = node.prev;
    }

    //移动当前节点到尾巴节点
    public void moveTotail(Node node) {
        removeNode(node);
        addToTail(node);
    }

    //添加到尾巴节点
    public void addToTail(Node node) {
        tail.prev.next = node;
        node.prev = tail.prev;
        node.next = tail;
        tail.prev = node;
    }

    //删除最近没使用的头结点
    public Node removeHead() {
        Node del = head.next;
        head.next = del.next;
        del.next.prev = head;
        return del;
    }

    //访问当前的key 把你访问的节点放到尾巴
    public int get(int key) {
        Node node = cache.get(key);
        if (node == null) {
            return -1;
        }
        //把最近使用的放到了尾巴
        moveTotail(node);
        printNodes("get");
        return node.val;
    }

    public void printNodes(String str) {
        System.out.println(str + " ");
        Node cur = head.next;
        while (cur != tail) {
            System.out.print(cur + " ");
            cur = cur.next;
        }
        System.out.println();
    }

    public static void main(String[] args) {
        MyLRUCache myLRUCache = new MyLRUCache(3);
        myLRUCache.put(100, 1);
        myLRUCache.put(200, 2);
        myLRUCache.put(300, 3);
        System.out.println("获取元素");
        myLRUCache.get(200);
        myLRUCache.get(100);
        System.out.println("存放元素，会删除头结点，因为头节点是最近最少使用的");
        myLRUCache.put(999, 9);
    }
}

3.jdk当中LRUCache被封装到了LinkedHashMap

package test;


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

public class LRUCache extends LinkedHashMap<String, Integer> {
    public int capacity;

    public LRUCache(int capacity) {
        super(capacity, 0.75f, true);
        this.capacity = capacity;
    }

    @Override
    public Integer get(Object key) {
        return super.getOrDefault(key, -1);
    }

    @Override
    public Integer put(String key, Integer value) {
        return super.put(key, value);
    }

    @Override
    protected boolean removeEldestEntry(Map.Entry<String, Integer> eldest) {
        return size() > capacity;
    }

    public static void main(String[] args) {
        LRUCache lruCache = new LRUCache(3);
        lruCache.put("a", 1);
        lruCache.put("b", 2);
        lruCache.put("c", 3);
        System.out.println(lruCache);
        System.out.println("获取元素");
        System.out.println(lruCache.get("b"));
        System.out.println(lruCache);
        System.out.println(lruCache.get("a"));
        System.out.println(lruCache);
        System.out.println("存放元素,会删除头结点，因为头结点是最近最少使用的");
        lruCache.put("d", 4);
        System.out.println(lruCache);
    }

    public static void main2(String[] args) {
        LinkedHashMap<String, Integer> linkedHashMap =
                new LinkedHashMap<String, Integer>(16, 0.7f, true);
        linkedHashMap.put("a", 1);
        linkedHashMap.put("b", 2);
        linkedHashMap.put("c", 3);
        System.out.println(linkedHashMap);
        System.out.println("获取元素");
        System.out.println(linkedHashMap.get("a"));
        System.out.println(linkedHashMap);
        System.out.println(linkedHashMap.get("b"));
        System.out.println(linkedHashMap);
        System.out.println(linkedHashMap.get("c"));
        System.out.println(linkedHashMap);//把常用的数据放到了尾巴 不常用的放在头部便于删除
    }

    public static void main1(String[] args) {
        LinkedHashMap<String, Integer> linkedHashMap =
                new LinkedHashMap<String, Integer>(16, 0.7f, false);
        linkedHashMap.put("a", 1);
        linkedHashMap.put("b", 2);
        linkedHashMap.put("c", 3);
        System.out.println(linkedHashMap);
        System.out.println("获取元素");
        System.out.println(linkedHashMap.get("a"));
        System.out.println(linkedHashMap);
    }
}

4.LRU缓存

 

class Node {
    public int key;
    public int val;

    public Node prev;

    public Node next;

    public Node() {

    }

    public Node(int key, int val) {
        this.key = key;
        this.val = val;
    }

    @Override
    public String toString() {
        return "Node{" +
                "key=" + key +
                ", val=" + val +
                '}';
    }
}

public class LRUCache {
    public Node head;
    public Node tail;

    public int usedsize;
    public Map<Integer, Node> cache;
    public int capacity;

    public LRUCache(int capacity) {
        this.head = new Node();
        this.tail = new Node();
        head.next = tail;
        tail.prev = head;
        cache = new HashMap<>();
        this.capacity = capacity;
    }

    //插入元素
    public void put(int key, int val) {
        Node node = cache.get(key);
        if (node == null) {
            Node newnode = new Node(key, val);
            cache.put(key, newnode);
            addToTail(newnode);
            usedsize++;
            //检查当前双向链表的有效数据个数 是不是超过了capacity
            if (usedsize > capacity) {
                Node removeNode = removeHead();
                cache.remove(removeNode.key);
                usedsize--;
            }
        } else {
            //更新val的值，其实没必要
            node.val = val;
            moveTotail(node);
        }
    }

    //删除指定节点
    public void removeNode(Node node) {
        node.prev.next = node.next;
        node.next.prev = node.prev;
    }

    //移动当前节点到尾巴节点
    public void moveTotail(Node node) {
        removeNode(node);
        addToTail(node);
    }

    //添加到尾巴节点
    public void addToTail(Node node) {
        tail.prev.next = node;
        node.prev = tail.prev;
        node.next = tail;
        tail.prev = node;
    }

    //删除最近没使用的头结点
    public Node removeHead() {
        Node del = head.next;
        head.next = del.next;
        del.next.prev = head;
        return del;
    }

    //访问当前的key 把你访问的节点放到尾巴
    public int get(int key) {
        Node node = cache.get(key);
        if (node == null) {
            return -1;
        }
        //把最近使用的放到了尾巴
        moveTotail(node);
        return node.val;
    }

    public void printNodes(String str) {
        System.out.println(str + " ");
        Node cur = head.next;
        while (cur != tail) {
            System.out.print(cur + " ");
            cur = cur.next;
        }
        System.out.println();
    }
}

阿瞒有我良计15
关注
  • 2
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Android缓存机制——LruCache的详解
08-26
"Android缓存机制——LruCache的详解" Android缓存机制LruCache是一种基于LinkedHashMap的缓存机制，它的核心思想是使用LRU（Least Recently Used）算法来管理缓存对象。LRU算法的核心思想是当缓存满时，会优先...
详解Android的内存优化--LruCache
08-31
**Android内存优化——详解LruCache** 在Android开发中，内存管理是至关重要的，尤其是在处理大量数据或资源时。为了提高应用性能并避免因内存不足导致的系统杀进程，开发者通常会采用缓存策略。其中，`LruCache` ...
Python - 深夜数据结构与算法之 LRUCache
BITDDD小栈
01-16 1396
Python LRU Cache 简介与算法练习。
一篇搞懂什么是LRU缓存｜一篇搞懂LRU缓存的实现｜LRUCache详解和实现
后端开发为主+人工智能
03-09 3596
一篇搞懂LRU缓存的原理
【数据结构】LRU Cache {什么是LRU Cache？LRU Cache的实现}
最新发布
芥末虾的博客
05-11 445
【数据结构】LRU Cache {什么是LRU Cache？LRU Cache的实现}
【数据结构】——LRU Cache
大三小白C++进阶之路
07-20 471
LRU Cache的原理和实现
【深入理解LRU Cache】：缓存算法的经典之作
StuLearn-LJC的博客
03-07 3752
​LRU Cache（Least Recently Used的缩写，即最近最少使用，它是一种Cache的替换算法。看Cache替换算法这篇文章）是一种常见的缓存淘汰算法。用于在有限的缓存空间中管理数据对象。LRU Cache 的核心思想是基于时间局部性原理，即最近被访问的数据在未来可能会被再次访问。
LruCache原理和用法与LinkedHashMap
喵了个呜的博客
08-25 1万+
一.LruCache算法LruCache算法就是Least Recently Used，也就是最近最少使用算法。他的算法就是当缓存空间满了的时候，将最近最少使用的数据从缓存空间中删除以增加可用的缓存空间来缓存新内容。这个算分的内部有一个缓存列表。每当一个缓存数据被访问的时候，这个数据就会被提到列表头部，每次都这样的话，列表的尾部数据就是最近最不常使用的了，当缓存空间不足时，就会删除列表尾部的缓存数据
【数据结构与算法】LRU Cache
joy.728的博客
02-02 1717
本篇博客主要讲解了什么是 LRU Cache 以及如何设计 LRU Cache等。
详解Android的内存优化–LruCache
01-05
LruCache 什么是LruCache？ LruCache实现原理是什么？ 这两个问题其实可以作为一个问题来回答，知道了什么是 LruCache，就只然而然的知道 LruCache 的实现原理；Lru的全称是Least Recently Used ，近期最少使用的！...
android lrucache
12-03
**Android LruCache详解** 在Android开发中，内存管理是一个至关重要的环节，特别是在处理大量图片或者数据时，如果不合理管理，很容易导致`OutOfMemoryError`(OOM)。Android提供了`LruCache`类，用于实现一个高效...
node-lru:nodejs实现的lru缓存
07-10
Node LRU Cache 基于Nodejs开发的LRU Cache, 兼有缓存超时清除功能 usage var options = { expires: 5 * 60 * 1000, capacity: 5 }; var LRU = require('node-lru'); var cache = new LRU(2);//var cache = new LRU(options); cache.set('key1', 'value1'); cache.set('key2', 'value2'); cache.set('key3', 'value3'); var value = cache.get('key2'); cache.on('extrusion', function (tail) { console.log(tail.key + ": " + tail.value)
LruCache缓存
02-06
### `LruCache`类详解 `LruCache`类位于Android的`android.util`包下，它是一个线程安全的缓存结构。开发者可以通过自定义缓存项的大小来限制缓存的最大容量。一旦超过这个容量，`LruCache`会自动按照LRU策略移除旧...
LRU Cache
MEANSWER的博客
06-28 500
LRU Cache1. 什么是LRU Cache2. LRU Cache的实现 1. 什么是LRU Cache LRU是Least Recently Used的缩写，意思是最近最少使用，它是一种Cache替换算法。 什么是Cache？狭义的Cache指的是位于CPU和主存间的快速RAM， 通常它不像系统主存那样使用DRAM技术，而使用昂贵但较快速的SRAM技术。 广义上的Cache指的是位于速度相差较大的两种硬件之间， 用于协调两者数据传输速度差异的结构。除了CPU与主存之间有Cache， 内存与硬盘之间也
缓存置换算法 - LRU算法
u010482601的专栏
09-09 2381
LRU算法 1 原理 对于在内存中并且不被使用的数据块就是LRU，这类数据需要从内存中删除，以腾出空间来存储常用的数据。 LRU算法（Least Recently Used，最近最少使用），是内存管理的一种页面置换算法，就是用来删除内存中不被使用的数据，腾出空间来把常用的数据存进去。 LRU算法的实现原理：把所有的缓存数据存入链表中，新插入的或被访问的数据存入链表头，如果链表满了，就把尾部...
HNU计算机系统实验缓存3&缓存4
君陌的博客
11-08 1649
1、编写更新LRU计数值函数： 当缓存成功时，本行系数LRU_count为最大值（人为设置），其他LRU_count-1 2、编写查找某组中牺牲行函数 遍历找到LRU_count数值最小的一行，作为牺牲行 3、编写命中判断函数 当符合要求的时候（组索引匹配，标记位（tag）相同，且该行有效值<valid_bit>为1），调用之前的updateLru函数对Lru_count进行更新...
LruCache实现原理分析
热门推荐
我是紫色紫色的专栏
02-22 2万+
LruCache是面试常客，你说你知道它是干啥的，却不知道它是怎么干的，你说这有啥用，知其然得知其所以然，所以一起看了看源码，一定会恍然大悟，以后面试可以有底气的说出它的工作原理了，那么一起来看看吧，代码不多，加上注释也就300多行。 我们可以打开LruCache.java的源码，第一行代码就是声明了一个变量 private final LinkedHashMap&lt;K, V&gt...
设计并实现一个LRU Cache
dbbaq24022的专栏
05-09 255
一、什么是Cache 1 概念 Cache，即高速缓存，是介于CPU和内存之间的高速小容量存储器。在金字塔式存储体系中它位于自顶向下的第二层，仅次于CPU寄存器。其容量远小于内存，但速度却可以接近CPU的频率。 当CPU发出内存访问请求时，会先查看 Cache 内是否有请求数据。 如果存在（命中），则直接返回该数据； 如果不存在（失效），再去访问内存 —...
LruCache 浅析
========
04-04 652
简介 LruCache (Least Recently Used) 是安卓中一个关于内存缓存的类，特别是在操作图片的时候，大量的图片会导致oom，所以采用lru，可以保持一个最大size的内存缓存，如果超过这个size，会把最少使用的缓存给移除，以保证内存不会不限增加移除的又是最少使用的缓存。 构造 通过构造可以看到，内部使用的是 LinkedHashMap ,真是这个关键的Linke...
rabbitmq详解
07-28
RabbitMQ是一个开源的消息代理软件，它实现了高级消息队列协议（AMQP）并提供可靠的消息传递机制。它可以用于构建分布式系统，处理大量的消息传递和异步通信。以下是关于RabbitMQ的一些详解： 1. 下载和安装：你可以从RabbitMQ官方网站下载RabbitMQ的安装包。你可以使用wget命令下载RabbitMQ的rpm包，例如：wget https://www.rabbitmq.com/releases/rabbitmq-server/v3.6.10/rabbitmq-server-3.6.10-1.el7.noarch.rpm。安装完成后，你可以双击安装包进行安装。安装完成后，你可以运行rabbitmq-plugins enable rabbitmq_management命令来安装RabbitMQ-Plugins插件。然后，你可以运行rabbitmq-server.bat来启动RabbitMQ服务。\[1\]\[2\] 2. 后台运行：如果你想在后台运行RabbitMQ，你可以使用rabbitmq-server -detached命令来启动RabbitMQ服务。如果你想停止RabbitMQ服务，你可以使用rabbitmqctl stop命令。\[3\] 总结起来，RabbitMQ是一个功能强大的消息代理软件，它可以用于构建分布式系统和处理大量的消息传递。你可以通过下载和安装RabbitMQ来开始使用它，并且可以选择在前台或后台运行RabbitMQ服务。 #### 引用[.reference_title] - *1* *2* [RabbitMQ详解，用心看完这一篇就够了【重点】](https://blog.csdn.net/weixin_42039228/article/details/123493937)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insertT0,239^v3^insert_chatgpt"}} ] [.reference_item] - *3* [RabbitMQ 详解](https://blog.csdn.net/m0_53067943/article/details/130578563)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insertT0,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

阿瞒有我良计15

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值