【面试题】LRU算法及编码实现LRU策略缓存

概念

  LRU(least recently used)就是将最近不被访问的数据给淘汰掉,LRU基于一种假设:认为最近使用过的数据将来被使用的概率也大,最近没有被访问的数据将来被使用的概率比较低。

原理

  LRU一般通过链表形式来存放缓存数据,新插入或被访问的数据放在链表头部,超过一定阈值后,自动淘汰链表尾部的数据。下图很形象的说明了LRU缓存淘汰过程。(图片来自网络)

步骤:

1、新插入A, 将A放置在队列头部

2、新插入B, 将B放置在队列头部, A自动推举次席。

3、新插入C, 将C放置在队列头部, B自动推举次席。

4、新插入D, 将D放置在队列头部, C自动推举次席。

5、新插入E, 将E放置在队列头部, D自动推举次席。

6、新插入E, 将E放置在队列头部, 这时队列长度大于阈值,自动将尾部数据A给淘汰掉

7、访问数据C,然后将C重新放置在队列头部。

8、新插入E, 将E放置在队列头部, 这时队列长度大于阈值,自动淘汰尾部数据B

编码实现LRU策略缓存

/**
 * Created by zhuhezan on 2018/4/11.
 *
 * 使用链表+hashmap来实现, 这里没有考虑并发情况, 所以在代码中没有使用锁
 */
public class LRUCache<K, V> {

    class CacheNode {
        public CacheNode before;
        public Object key;
        public Object value;
        public CacheNode after;

        public CacheNode() {
        }
    }

    private HashMap<K, CacheNode> caches;
    private int maxCapacity;
    private int currentCacheSize;
    /**
     * 头结点, 头结点不参与淘汰,只是作为标识链表中的第一个节点
     */
    private CacheNode head;
    /**
     * 尾节点, 尾节点不参与淘汰, 只是作为标识链表中最后一个节点
     */
    private CacheNode tail;

    public LRUCache(int maxCapacity) {
        this.maxCapacity = maxCapacity;
        caches = new HashMap<>(maxCapacity);
        head = tail = new CacheNode();
        head.after = tail; //对head 的after节点赋值, 防止后续操作出现空指针异常
        tail.before = head; // 对tail的before节点赋值, 防止后续操作出现空指针异常
    }

    public void put(K k, V v) {
        CacheNode node = caches.get(k);
        if (node == null) {
            if (currentCacheSize >= maxCapacity) {
                caches.remove(tail.before.key); //淘汰尾部的元素
                removeLast();
            }

            node = new CacheNode();
            node.key = k;

            currentCacheSize ++;
        }

        node.value = v;
        moveToFirst(node); // LRU策略, 新插入的元素放置到队列头部
        caches.put(k, node);
    }

    public void moveToFirst(CacheNode node) {
        CacheNode n = head.after;
        head.after = node;
        node.before = head;
        n.before = node;
        node.after = n;
    }

    public void removeLast() {
        CacheNode n = tail.before.before;
        n.after = tail;
        tail.before = n;
    }

    public Object get(K k) {
        CacheNode node = caches.get(k);
        if (node == null) {
            return null;
        }

        Object v = node.value;
        moveToFirst(node);
        return v;
    }

    public Object remove(K k) {
        CacheNode node = caches.get(k);
        if (node == null) {
            return null;
        }

        CacheNode pre = node.before;
        CacheNode next = node.after;
        pre.after = next;
        next.before = pre;

        caches.remove(k);

        currentCacheSize --;
        return node.value;
    }
}

上述代码在博主本机测试验证通过(单线程操作下)

原文地址:https://www.cnblogs.com/jsnr-tdyd/p/8800649.html

时间: 2024-10-10 12:09:14

【面试题】LRU算法及编码实现LRU策略缓存的相关文章

redis的LRU算法(一)

最近加班比较累,完全不想写作了.. 刚看到一篇有趣的文章,是redis的作者antirez对redis的LRU算法的回顾.LRU算法是Least Recently Used的意思,将最近最少使用的资源丢掉.Redis经常被用作cache,如果能够将不常用的key移除,尽量保留常用的,那内存的利用率就相当高了.当然,LRU也有弱点,考虑下面一种情况: ~~~~~A~~~~~A~~~~~A~~~~A~~~~~A~~~~~A~~| ~~B~~B~~B~~B~~B~~B~~B~~B~~B~~B~~B~~

关于LRU算法(转载)

原文地址: http://flychao88.iteye.com/blog/1977653 http://blog.csdn.net/cjfeii/article/details/47259519 LRU(Least recently used,最近最少使用)算法根据数据的历史访问记录来进行淘汰数据,其核心思想是"如果数据最近被访问过,那么将来被访问的几率也更高". 1.2.实现 最常见的实现是使用一个链表保存缓存数据,详细算法实现如下: 1. 新数据插入到链表头部: 2. 每当缓存命

探究redis和memcached的 LRU算法--------redis的LRU的实现

一直对这redis和memcached的两个开源缓存系统的LRU算法感兴趣.今天就打算总结一下这两个LRU算法的实现和区别. 首先要知道什么是LRU算法:LRU是Least Recently Used 近期最少使用算法.相关的资料网上一大堆.http://en.wikipedia.org/wiki/Cache_algorithms#LRU   redis的六种策略 rewriteConfigEnumOption(state,"maxmemory-policy",server.maxme

【算法】LRU算法

缓存一般存放的都是热点数据,而热点数据又是利用LRU(最近最久未用算法)对不断访问的数据筛选淘汰出来的. 出于对这个算法的好奇就查了下资料. LRU算法四种实现方式介绍 缓存淘汰算法 原文地址:https://www.cnblogs.com/2YSP/p/10424376.html

FIFO调度算法和LRU算法

一.理论 FIFO:先进先出调度算法 LRU:最近最久未使用调度算法 两者都是缓存调度算法,经常用作内存的页面置换算法. 打一个比方,帮助你理解.你有很多的书,比如说10000本.由于你的书实在太多了,你只能放在地下室里面.你看书的时候不会在地下室看书,而是在书房看书.每次,你想看书都必须跑到地下室去找出来你想看的书,然后抱回来放到书桌上,之后才开始看.还有就是,有一些书你会反复的看,今天看了也许过几天又要看.总之,你自己是不知道你哪天会需要看哪本书的.你的老师每天下课的时候会给你布置一个书单,

LRU算法原理解析

LRU是Least Recently Used的缩写,即最近最少使用,常用于页面置换算法,是为虚拟页式存储管理服务的. 现代操作系统提供了一种对主存的抽象概念虚拟内存,来对主存进行更好地管理.他将主存看成是一个存储在磁盘上的地址空间的高速缓存,在主存中只保存活动区域,并根据需要在主存和磁盘之间来回传送数据.虚拟内存被组织为存放在磁盘上的N个连续的字节组成的数组,每个字节都有唯一的虚拟地址,作为到数组的索引.虚拟内存被分割为大小固定的数据块虚拟页(Virtual Page,VP),这些数据块作为主

缓存淘汰算法--LRU算法

1. LRU1.1. 原理 LRU(Least recently used,最近最少使用)算法根据数据的历史访问记录来进行淘汰数据,其核心思想是"如果数据最近被访问过,那么将来被访问的几率也更高". 1.2. 实现 最常见的实现是使用一个链表保存缓存数据,详细算法实现如下: 1. 新数据插入到链表头部: 2. 每当缓存命中(即缓存数据被访问),则将数据移到链表头部: 3. 当链表满的时候,将链表尾部的数据丢弃. 1.3. 分析 [命中率] 当存在热点数据时,LRU的效率很好,但偶发性的

LRU算法 - LRU Cache

这个是比较经典的LRU(Least recently used,最近最少使用)算法,算法根据数据的历史访问记录来进行淘汰数据,其核心思想是“如果数据最近被访问过,那么将来被访问的几率也更高”. 一般应用在缓存替换策略中.其中的”使用”包括访问get和更新set. LRU算法 LRU是Least Recently Used 近期最少使用算法.内存管理的一种页面置换算法,对于在内存中但又不用的数据快(内存块)叫做LRU,Oracle会根据那些数据属于LRU而将其移出内存而腾出空间来加载另外的数据,一

LRU算法的Python实现

LRU:least recently used,最近最少使用算法.它的使用场景是:在有限的空间中存储对象时,当空间满时,会一定的原则删除原有的对象,常用的原则(算法)有LRU,FIFO,LFU等.在计算机的Cache硬件,以及主存到虚拟内存的页面置换,还有Redis缓存系统中都用到了该算法.我在一次面试和一个笔试时,都遇到过这个问题. LRU的算法是比较简单的,当对key进行访问时(一般有查询,更新,增加,在get()和set()两个方法中实现即可)时,将该key放到队列的最前端(或最后端)就行