fifo算法_FIFO/LRU/LFU三种缓存算法

最新推荐文章于 2021-03-06 00:40:23 发布
最新推荐文章于 2021-03-06 00:40:23 发布
阅读量252 收藏
点赞数
文章标签： fifo算法 java 最少使用(lru)置换算法 最近最久未使用算法c语言

7411577733604c20889f9dbbb60ff306.png

FIFO

先进先出，如果缓存容量满，则优先移出最早加入缓存的数据；其内部可以使用队列实现。

特点

1）Object get(key)：获取保存的数据，如果数据不存在或者已经过期，则返回null。

2）void put(key,value,expireTime)：加入缓存，无论此key是否已存在，均作为新key处理（移除旧key）；如果空间不足，则移除已过期的key，如果没有，则移除最早加入缓存的key。过期时间未指定，则表示永不自动过期。

3）此题需要注意，我们允许key是有过期时间的，这一点与普通的FIFO有所区别，所以在设计此题时需要注意。（也是面试考察点，此题偏设计而非算法）

普通的FIFO或许大家都能很简单的写出，此处增加了过期时间的特性，所以在设计时需要多考虑。如下示例，为FIFO的简易设计，尚未考虑并发环境场景。

设计思路

1）用普通的hashMap保存缓存数据。

2）我们需要额外的map用来保存key的过期特性，例子中使用了TreeMap，将“剩余存活时间”作为key，利用treemap的排序特性。

public class FIFOCache {  



    //按照访问时间排序,保存所有key-value  

    private final Map<String,Value> CACHE = new LinkedHashMap<>();  



    //过期数据，只保存有过期时间的key  

    //暂不考虑并发，我们认为同一个时间内没有重复的key，如果改造的话，可以将value换成set  

    private final TreeMap<Long, String> EXPIRED = new TreeMap<>();  



    private final int capacity;  



    public FIFOCache(int capacity) {  

        this.capacity = capacity;  

    }  



    public Object get(String key) {  

        //  

        Value value = CACHE.get(key);  

        if (value == null) {  

            return null;  

        }  



        //如果不包含过期时间  

        long expired = value.expired;  

        long now = System.nanoTime();  

        //已过期  

        if (expired > 0 && expired <= now) {  

            CACHE.remove(key);  

            EXPIRED.remove(expired);  

            return null;  

        }  

        return value.value;  

    }  



    public void put(String key,Object value) {  

        put(key,value,-1);  

    }  





    public void put(String key,Object value,int seconds) {  

        //如果容量不足，移除过期数据  

        if (capacity < CACHE.size()) {  

            long now = System.nanoTime();  

            //有过期的,全部移除  

            Iterator<Long> iterator = EXPIRED.keySet().iterator();  

            while (iterator.hasNext()) {  

                long _key = iterator.next();  

                //如果已过期，或者容量仍然溢出，则删除  

                if (_key > now) {  

                    break;  

                }  

                //一次移除所有过期key  

                String _value = EXPIRED.get(_key);  

                CACHE.remove(_value);  

                iterator.remove();  

            }  

        }  



        //如果仍然容量不足，则移除最早访问的数据  

        if (capacity < CACHE.size()) {  

            Iterator<String> iterator = CACHE.keySet().iterator();  

            while (iterator.hasNext() && capacity < CACHE.size()) {  

                String _key = iterator.next();  

                Value _value = CACHE.get(_key);  

                long expired = _value.expired;  

                if (expired > 0) {  

                    EXPIRED.remove(expired);  

                }  

                iterator.remove();  

            }  

        }  



        //如果此key已存在,移除旧数据  

        Value current = CACHE.remove(key);  

        if (current != null && current.expired > 0) {  

            EXPIRED.remove(current.expired);  

        }  

        //如果指定了过期时间  

        if(seconds > 0) {  

            long expireTime = expiredTime(seconds);  

            EXPIRED.put(expireTime,key);  

            CACHE.put(key,new Value(expireTime,value));  

        } else {  

            CACHE.put(key,new Value(-1,value));  

        }  



    }  



    private long expiredTime(int expired) {  

        return System.nanoTime() + TimeUnit.SECONDS.toNanos(expired);  

    }  



    public void remove(String key) {  

        Value value = CACHE.remove(key);  

        if(value == null) {  

            return;  

        }  

        long expired = value.expired;  

        if (expired > 0) {  

            EXPIRED.remove(expired);  

        }  

    }  





    class Value {  

        long expired; //过期时间,纳秒  

        Object value;  

        Value(long expired,Object value) {  

            this.expired = expired;  

            this.value = value;  

        }  

    }  

}

LRU

least recently used，最近最少使用，是目前最常用的缓存算法和设计方案之一，其移除策略为“当缓存（页）满时，优先移除最近最久未使用的数据”，优点是易于设计和使用，适用场景广泛。算法可以参考leetcode 146 （LRU Cache）。

特点

1）Object get(key)：从canche中获取key对应的数据，如果此key已过期，移除此key，并则返回null。

2）void put(key,value,expired)：设置k-v，如果容量不足，则根据LRU置换算法移除“最久未被使用的key”，需要注意，根据LRU优先移除已过期的keys，如果没有，则根据LRU移除未过期的key。如果未设定过期时间，则认为永不自动过期。

3）此题，设计关键是过期时间特性，这与常规的LRU有所不同。毕竟“过期时间”特性在cache设计中是必要的。

设计思路

1）LRU的基础算法，需要了解；每次put、get时需要更新key对应的访问时间，我们需要一个数据结构能够保存key最近的访问时间且能够排序。

2）既然包含过期时间特性，那么带有过期时间的key需要额外的数据结构保存。

3）暂时不考虑并发操作；尽量兼顾空间复杂度和时间复杂度。

4）此题仍然偏向于设计题，而非纯粹的算法题。

此题代码与FIFO基本相同，唯一不同点为get()方法，对于LRU而言，get方法需要重设访问时间（即调整所在cache中顺序）

public Object get(String key) {  

    //  

    Value value = CACHE.get(key);  

    if (value == null) {  

        return null;  

    }  



    //如果不包含过期时间  

    long expired = value.expired;  

    long now = System.nanoTime();  

    //已过期  

    if (expired > 0 && expired <= now) {  

        CACHE.remove(key);  

        EXPIRED.remove(expired);  

        return null;  

    }  

    //相对于FIFO，增加顺序重置  

    CACHE.remove(key);  

    CACHE.put(key,value);  

    return value.value;  

}

LFU

最近最不常用，当缓存容量满时，移除访问次数最少的元素，如果访问次数相同的元素有多个，则移除最久访问的那个。设计要求参见leetcode 460（ LFU Cache）

public class LFUCache {  



    //主要容器，用于保存k-v  

    private Map<String, Object> keyToValue = new HashMap<>();  



    //记录每个k被访问的次数  

    private Map<String, Integer> keyToCount = new HashMap<>();  



    //访问相同次数的key列表，按照访问次数排序，value为相同访问次数到key列表。  

    private TreeMap<Integer, LinkedHashSet<String>> countToLRUKeys = new TreeMap<>();  



    private int capacity;  



    public LFUCache(int capacity) {  

        this.capacity = capacity;  

        //初始化，默认访问1次，主要是解决下文  

    }  



    public Object get(String key) {  

        if (!keyToValue.containsKey(key)) {  

            return null;  

        }  



        touch(key);  

        return keyToValue.get(key);  

    }  



    /** 

     * 如果一个key被访问，应该将其访问次数调整。 

     * @param key 

     */  

    private void touch(String key) {  

        int count = keyToCount.get(key);  

        keyToCount.put(key, count + 1);//访问次数增加  

        //从原有访问次数统计列表中移除  

        countToLRUKeys.get(count).remove(key);  



        //如果符合最少调用次数到key统计列表为空，则移除此调用次数到统计  

        if (countToLRUKeys.get(count).size() == 0) {  

            countToLRUKeys.remove(count);  

        }  



        //然后将此key的统计信息加入到管理列表中  

        LinkedHashSet<String> countKeys = countToLRUKeys.get(count + 1);  

        if (countKeys == null) {  

            countKeys = new LinkedHashSet<>();  

            countToLRUKeys.put(count + 1,countKeys);  

        }  

        countKeys.add(key);  

    }  



    public void put(String key, Object value) {  

        if (capacity <= 0) {  

            return;  

        }  



        if (keyToValue.containsKey(key)) {  

            keyToValue.put(key, value);  

            touch(key);  

            return;  

        }  

        //容量超额之后，移除访问次数最少的元素  

        if (keyToValue.size() >= capacity) {  

            Map.Entry<Integer,LinkedHashSet<String>> entry = countToLRUKeys.firstEntry();  

            Iterator<String> it = entry.getValue().iterator();  

            String evictKey = it.next();  

            it.remove();  

            if (!it.hasNext()) {  

                countToLRUKeys.remove(entry.getKey());  

            }  

            keyToCount.remove(evictKey);  

            keyToValue.remove(evictKey);  



        }  



        keyToValue.put(key, value);  

        keyToCount.put(key, 1);  

        LinkedHashSet<String> keys = countToLRUKeys.get(1);  

        if (keys == null) {  

            keys = new LinkedHashSet<>();  

            countToLRUKeys.put(1,keys);  

        }  

        keys.add(key);  

    }  

}

232f9031d46b496992525cdcd11ac248.png
weixin_39984578
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
课程设计 FIFO算法的实现
12-06
课程设计 FIFO算法的实现 有关页面调度的算法，FIFO OPT NUR LRU
FIFO，LRU，LFU 的三种页面置换算法的C++实现
最新发布
04-09
OS操作系统上机题 FIFO，LRU，LFU 的三种页面置换算法的C++实现 {3,2,1,3,2,5,2,3,6,2,1,4,2} 为本实验例子的页面走向 copy直接可运行 提供简单可视化菜单 三种页面置换算法可供选择 注释详细，初学者亦可看懂
缓存算法（页面置换算法）-FIFO、LFU、LRU
weixin_30340353的博客
05-24 287
缓存算法（页面置换算法）-FIFO、LFU、LRU 　　在前一篇文章中通过leetcode的一道题目了解了LRU算法的具体设计思路，下面继续来探讨一下另外两种常见的Cache算法：FIFO、LFU 1.FIFO算法 　　FIFO（First in First out），先进先出。其实在操作系统的设计理念中很多地方都利用到了先进先出的思想，比如作业调度（先来先服务），为什么这个原则在很多地方都...
3种堆内缓存算法，赠源码和设计思路
小姐姐味道
05-11 574
原创：小姐姐味道（微信公众号ID：xjjdog），欢迎分享，转载请保留出处。要说计算机系统里，什么技术把tradeoff体现的淋漓尽致，那肯定是缓存无疑。为了协调高速部件和低速部件的速度...
先进先出缓存算法(FIFO)--java实现
xiaocai9999的专栏
09-08 1240
操作系统中的虚拟内存管理系统可采用先进先出算法的方式缓存。 当请求的内存页不在缓存中。且缓存已满时，应从缓存中删除保存时间最长的页面， 从而为请求页面腾出空间，如果缓存未满，可直接将请求页面添加到缓存中， 给定的页面最多只应在缓存中出现一次。 构造FIFO类的构造方法为countCacheMiss。 该方法输入包括一个整数max_cache_size,和一个页面请求数组page_
fifo算法模拟_[源码和文档分享]基于C++的请求分页虚拟页面替换算法
weixin_39554290的博客
11-30 180
一、需求分析实现OPT、FIFO、LRU、Clock等页面替换算法。接收用户输入参数，包括程序长度（页面数）、页框个数及页面大小，输出结果采用不同颜色区分命中、替换及直接加入空闲块。OPT（最佳置换算法）：其所选择的被淘汰页面将是以后永不使用的，或许是在最长（未来）时间内不再被访问的页面，但是由于无法预知一个进程在内存中的若干个页面中，哪一个页面是未来最长时间内不被访问的，因而该算法无法实现FIF...
suanfa.rar_fifo_页面置换算法 ；LRU ；LFU；OPT
09-24
本文将深入探讨四种页面置换算法：FIFO（先进先出）、LRU（最近最少使用）、LFU（最不经常使用）以及OPT（最佳页面置换）。这些算法都是为了解决内存不足时如何选择将哪个页面移出内存的问题。 首先，我们来理解...
fifo.rar_FIFO LRU_LRU_c fifo_fifo_visual c
09-22
在计算机科学领域，缓存管理是优化系统性能的关键部分，其中FIFO（First In First Out）和LRU（Least Recently Used）是最常见的两种缓存替换策略。本篇将深入探讨这两种算法的实现，并以C语言作为编程语言进行阐述...
yuandaima.rar_LFU_LFU NUR _OPT_OPT FIFO LRU LFU
09-22
设计一个虚拟存储区和内存工作区 , 并使用下述算法计算访问命中率。...(1) 先进先出的算法 (FIFO) (2 )最近最少使用算法 (LRU) (3) 最佳淘汰算法 (OPT) (4) 最少访问页面算法 (LFU) (5 )最近最不经常使用算法 (NUR)
aaa.rar_FIFO LRU OPT_OPT FIFO LRU_OPT_ LRU_ FIFO_java fifo lru_l
09-24
本文将详细讨论三种常见的缓存淘汰策略：FIFO（First In First Out）、LRU（Least Recently Used）以及OPT（Optimal）。这些策略的Java实现是编程实践中的常见需求，下面我们将逐一探讨它们的原理和实现。 1. FIFO...
FIFO算法实现
05-21
FIFO算法的c语言实现 详细代码 以及详细注释
FIFO置换算法（java代码实现）
06-22
操作系统页面置换算法中的FIFO算法，这个是用java代码实现的，纯代码，经验证是完全正确的。
FIFO先进先出调度算法（含代码截图）
06-18
利用书本上所将的先进先出页面调度算法的思想，每当有新的页面进入时将会产生页面中断，而被淘汰的将是最先进入的页面。然后按照书上的要求输入页面号
先进先出（FIFO）页面置换算法
02-20
这是 我在今年的操作系统的课程设计的题目。代码的经过了老师的BT检测，绝对可用。编写简单，易懂。欢迎下载，交流！
fifo算法_CPU中的高速缓存与置换算法
weixin_39764379的博客
11-30 357
早期计算机仅限于固定用途的程序，程序是固定在电路板上的，修改程序的话，需要重新设计电路，冯诺依曼体系确立了通用的计算机结构。1.2 冯诺依曼体系概述输入设备：用于完成数据的接收，将数据送入到运算器中控制器：控制器是整个计算机的指挥控制中心，通过向其他设备发出控制信号来控制、控制计算机，使其能自动、协调地工作。运算器：在控制器的统一控制下，负责对数据进行加工、完成各种运算，如算术运算、逻辑运算、位移...
fifo页面置换算法java_缓存算法（页面置换算法）-FIFO、LFU、LRU
weixin_34565946的博客
03-06 404
转自：http://www.cnblogs.com/dolphin0520/1.FIFO算法FIFO(First in First out)，先进先出。其实在操作系统的设计理念中很多地方都利用到了先进先出的思想，比如作业调度(先来先服务)，为什么这个原则在很多地方都会用到呢？因为这个原则简单、且符合人们的惯性思维，具备公平性，并且实现起来简单，直接使用数据结构中的队列即可实现。在FIFO Cach...
fifo页面置换算法设计思路_说说限流算法与设计思路
weixin_31959079的博客
01-15 432
都知道目前的常规的限流算法有令牌桶和漏桶算法.今天就这些限流常见的算法给大家做一个详细的介绍与实现思路.固定窗口这个算法是最为简单的一个算法,Redis存储key和value,key是任意的,value代表一秒内请求的值,设置一个计时器每个一秒钟将限流的key设置为0.当有请求来临时执行incr key,key超出了一定值后进行限流.滑动窗口tcp就是使用的滑动窗口策略来限制发送的速率.但是tcp...
操作系统页面置换算法（最佳置换算法，FIFO，LRU，Clock）
qq_45872719的博客
12-05 7843
页面置换算法为什么要页面置换最佳置换算法先进先出页面置换算法LRU置换算法Clock置换算法 为什么要页面置换 缺页中断： 在地址映射过程中，若在页表中发现所要访问的页面不在内存，则产生中断，当发生中断时，系统必须在内存选择一个页面移出内存，以便为调入新的页面让出空间。 缺页率的计算： 假设一个进程的逻辑空间为n页，系统为其分配的物理块数为m，如果在进程运行的过程当中，访问页面成功（即所访问的页面在内存中）的次数为S，访问页面失败（即所访问的页面不在内存中）的次数为F，则该进程的页面确实率 f=F/
fifo算法_高性能编程之缓存淘汰算法
weixin_39623050的博客
11-30 203
我们知道内存的容量比起磁盘来要小很多，因为磁盘价格比较低，而内存的价格比较高，所以在一般项目中，内存中都不可能存储全量的数据，所以需要有很好的机制来保证，留在内存中的数据是热点数据，能够帮助我们解决性能问题。1 、FIFO：先进先出算法算法描述 ：这应该是最简单了算法了， 我们一般需要创建一个队列(queue),队列的尾部存放最新进入队列的缓存对象。队列的头部存放最早进入队列的缓存对象。 当内存满...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值