FIFO、LRU、LFU三种缓存淘汰算法

最新推荐文章于 2023-08-15 22:32:17 发布
最新推荐文章于 2023-08-15 22:32:17 发布
阅读量433 收藏
点赞数
分类专栏： 算法 文章标签： 算法 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CarrotZsy/article/details/114844371
版权

本文介绍三种常用缓存淘汰算法，即它们的简单实现。

简介

缓存，就是将程序或系统经常要调用的对象存在内存中，再次调用时可以快速从内存中获取对象，不必再去创建新的重复的实例。
当缓存中的数据太多超过一定值时，通常会采取一些缓存淘汰算法进行处理。

FIFO（先进先出）

FIFO即先进先出算法，队列也具有先进先出的性质，所以可以考虑采用LinkedList实现FIFO算法。但是只用LinkedList的话，查找时时间复杂度为O(n)，所以可以考虑采用HashMap+LinkedList实现。

public class FIFOCache<K,V>{
    private Map<K,V> cache;
    private LinkedList<K> list;
    private volatile int maxCapacity;
    private final Lock lock;

    public FIFOCache(){
        this(1000);
    }

    public FIFOCache(int maxCapacity){
        this.maxCapacity = maxCapacity;
        this.lock = new ReentrantLock();
        this.cache = new HashMap<>();
        this.list = new LinkedList<>();
    }

    public V get(K key){
        this.lock.lock();

        V var;
        try {
            var = this.cache.get(key);
        }finally {
            this.lock.unlock();
        }
        return var;
    }

    public void put(K key, V value){
        this.lock.lock();

        try {
            this.list.addLast(key);
            if (maxCapacity < this.list.size()){
                K k = this.list.getFirst();
                cache.remove(k);
                this.list.removeFirst();
            }
            this.cache.put(key, value);
        }finally {
            this.lock.unlock();
        }
    }

    @Override
    public String toString() {
        return "FIFOCache{" +
                "cache=" + cache +
                ", list=" + list +
                ", maxCapacity=" + maxCapacity +
                ", lock=" + lock +
                '}';
    }
}

测试类

public class TestFIFO {
    public static void main(String[] args) {
        FIFOCache<String,String> fifoCache = new FIFOCache<String,String>(3);

        fifoCache.put("1","a");
        fifoCache.put("2","b");
        fifoCache.put("3","c");
        fifoCache.put("4","d");

        System.out.println(fifoCache.toString());

        System.out.println(fifoCache.get("2"));
    }
}

FIFO算法

LRU（最近最久未使用）

LRU（The Least Recently Used，最近最久未使用算法）是一种常见的缓存算法，在很多分布式缓存系统（如Redis, Memcached）中都有广泛使用。

LRU算法的思想是：如果一个数据在最近一段时间没有被访问到，那么可以认为在将来它被访问的可能性也很小。因此，当空间满时，最久没有访问的数据最先被置换（淘汰）。

实现

  1. 数组+时间戳 （时间复杂度较高O(n)）
  2. 链表 （查询时间复杂度还是O(n)）每次将访问到的节点移到链表尾部
  3. 哈希表+双向链表（LinkedHashMap）

Dubbo中的LRU实现

package cache;

import java.util.LinkedHashMap;
import java.util.Map;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author zousy
 * @version v1.0
 * @Description
 * @date 2021-03-16 14:46
 */
public class LRUCache<K, V> extends LinkedHashMap<K, V> {
    
    private static final float DEFAULT_LOAD_FACTOR = 0.75F;
    private static final int DEFAULT_MAX_CAPACITY = 1000;
    private final Lock lock;
    private volatile int maxCapacity;

    public LRUCache() {
        this(1000);
    }

    public LRUCache(int maxCapacity) {
        super(16, 0.75F, true);
        this.lock = new ReentrantLock();
        this.maxCapacity = maxCapacity;
    }

    @Override
    protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
        return this.size() > this.maxCapacity;
    }

    @Override
    public boolean containsKey(Object key) {
        this.lock.lock();

        boolean var2;
        try {
            var2 = super.containsKey(key);
        } finally {
            this.lock.unlock();
        }

        return var2;
    }

    @Override
    public V get(Object key) {
        this.lock.lock();

        Object var2;
        try {
            var2 = super.get(key);
        } finally {
            this.lock.unlock();
        }

        return (V) var2;
    }

    @Override
    public V put(K key, V value) {
        this.lock.lock();

        Object var3;
        try {
            var3 = super.put(key, value);
        } finally {
            this.lock.unlock();
        }

        return (V) var3;
    }

    @Override
    public V remove(Object key) {
        this.lock.lock();

        Object var2;
        try {
            var2 = super.remove(key);
        } finally {
            this.lock.unlock();
        }

        return (V) var2;
    }

    @Override
    public int size() {
        this.lock.lock();

        int var1;
        try {
            var1 = super.size();
        } finally {
            this.lock.unlock();
        }

        return var1;
    }

    @Override
    public void clear() {
        this.lock.lock();

        try {
            super.clear();
        } finally {
            this.lock.unlock();
        }

    }

    public int getMaxCapacity() {
        return this.maxCapacity;
    }

    public void setMaxCapacity(int maxCapacity) {
        this.maxCapacity = maxCapacity;
    }
}

测试类

public class TestLRUCache {
    private static LRUCache<String, Integer> cache = new LRUCache<>(10);

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            cache.put("k" + i, i);
        }
        System.out.println("all cache :'{"+cache+"}'");
        cache.get("k3");
        System.out.println("get k3 :'{"+cache+"}'");
        cache.get("k4");
        System.out.println("get k4 :'{"+cache+"}'");
        cache.get("k4");
        System.out.println("get k4 :'{"+cache+"}'");
        cache.put("k" + 10, 10);
        System.out.println("After running the LRU algorithm cache :'{"+cache+"}'");
    }
}

结果

LFU（最近最少使用）

LFU（Least Frequently Used ，最近最少使用算法）也是一种常见的缓存算法。

LFU算法的思想是：如果一个数据在最近一段时间很少被访问到，那么可以认为在将来它被访问的可能性也很小。因此，当空间满时，最小频率访问的数据最先被淘汰。

算法实现策略：考虑到 LFU 会淘汰访问频率最小的数据，我们需要一种合适的方法按大小顺序维护数据访问的频率。

实现

  1. 计算器+链表+哈希表
  2. LIFO的Deque数组+哈希表+链表

这里看下Dubbo中的LFU算法的实现。

public class LFUCache<K, V> {
    private Map<K, LFUCache.CacheNode<K, V>> map;
    private LFUCache.CacheDeque<K, V>[] freqTable; 
    private final int capacity;
    private int evictionCount;
    private int curSize;
    private final ReentrantLock lock;
    private static final int DEFAULT_LOAD_FACTOR = 1000;
    private static final float DEFAULT_EVICTION_CAPACITY = 0.75F;//默认淘汰因子

    public LFUCache() {
        this(1000, 0.75F);
    }

    public LFUCache(final int maxCapacity, final float evictionFactor) {
        this.curSize = 0;
        this.lock = new ReentrantLock();
        if (maxCapacity <= 0) {
            throw new IllegalArgumentException("Illegal initial capacity: " + maxCapacity);
        } else {
            boolean factorInRange = evictionFactor <= 1.0F || evictionFactor < 0.0F;
            if (factorInRange && !Float.isNaN(evictionFactor)) {
                this.capacity = maxCapacity;
                this.evictionCount = (int)((float)this.capacity * evictionFactor);
                this.map = new HashMap();
                this.freqTable = new LFUCache.CacheDeque[this.capacity + 1];

                int i;
                for(i = 0; i <= this.capacity; ++i) {
                    this.freqTable[i] = new LFUCache.CacheDeque();
                }

                for(i = 0; i < this.capacity; ++i) {
                    this.freqTable[i].nextDeque = this.freqTable[i + 1];
                }

                this.freqTable[this.capacity].nextDeque = this.freqTable[this.capacity];
            } else {
                throw new IllegalArgumentException("Illegal eviction factor value:" + evictionFactor);
            }
        }
    }

    public int getCapacity() {
        return this.capacity;
    }

    public V put(final K key, final V value) {
        this.lock.lock();

        LFUCache.CacheNode node;
        try {
            if (this.map.containsKey(key)) {
                node = (LFUCache.CacheNode)this.map.get(key);
                if (node != null) {
                    LFUCache.CacheNode.withdrawNode(node);
                }

                node.value = value;
                this.freqTable[0].addLastNode(node);
                this.map.put(key, node);
            } else {
                node = this.freqTable[0].addLast(key, value);
                this.map.put(key, node);
                ++this.curSize;
                if (this.curSize > this.capacity) {
                    this.proceedEviction();
                }
            }
        } finally {
            this.lock.unlock();
        }

        return node.value;
    }

    public V remove(final K key) {
        LFUCache.CacheNode<K, V> node = null;
        this.lock.lock();

        try {
            if (this.map.containsKey(key)) {
                node = (LFUCache.CacheNode)this.map.remove(key);
                if (node != null) {
                    LFUCache.CacheNode.withdrawNode(node);
                }

                --this.curSize;
            }
        } finally {
            this.lock.unlock();
        }

        return node != null ? node.value : null;
    }

    public V get(final K key) {
        LFUCache.CacheNode<K, V> node = null;
        this.lock.lock();

        try {
            if (this.map.containsKey(key)) {
                node = (LFUCache.CacheNode)this.map.get(key);
                LFUCache.CacheNode.withdrawNode(node);
                //数组下一个位置存放访问过的值,相当于访问过n次。淘汰时，根据对应位置链表长度进行淘汰。
                node.owner.nextDeque.addLastNode(node);
            }
        } finally {
            this.lock.unlock();
        }

        return node != null ? node.value : null;
    }

    private int proceedEviction() {
        int targetSize = this.capacity - this.evictionCount;//允许缓存的大小 = 容量-容量*淘汰因子
        int evictedElements = 0;

        for(int i = 0; i <= this.capacity; ++i) {
            while(!this.freqTable[i].isEmpty()) {
                LFUCache.CacheNode<K, V> node = this.freqTable[i].pollFirst();
                this.remove(node.key);
                if (targetSize >= this.curSize) {
                    return evictedElements;
                }

                ++evictedElements;
            }
        }

        return evictedElements;
    }

    public int getSize() {
        return this.curSize;
    }
	
    static class CacheDeque<K, V> {
        LFUCache.CacheNode<K, V> last = new LFUCache.CacheNode();
        LFUCache.CacheNode<K, V> first = new LFUCache.CacheNode();
        LFUCache.CacheDeque<K, V> nextDeque;

        CacheDeque() {
            this.last.next = this.first;
            this.first.prev = this.last;
        }

        LFUCache.CacheNode<K, V> addLast(final K key, final V value) {
            LFUCache.CacheNode<K, V> node = new LFUCache.CacheNode(key, value);
            node.owner = this;
            node.next = this.last.next;
            node.prev = this.last;
            node.next.prev = node;
            this.last.next = node;
            return node;
        }

        LFUCache.CacheNode<K, V> addLastNode(final LFUCache.CacheNode<K, V> node) {
            node.owner = this;
            node.next = this.last.next;
            node.prev = this.last;
            node.next.prev = node;
            this.last.next = node;
            return node;
        }

        LFUCache.CacheNode<K, V> pollFirst() {
            LFUCache.CacheNode<K, V> node = null;
            if (this.first.prev != this.last) {
                node = this.first.prev;
                this.first.prev = node.prev;
                this.first.prev.next = this.first;
                node.prev = null;
                node.next = null;
            }

            return node;
        }

        boolean isEmpty() {
            return this.last.next == this.first;
        }
    }

    static class CacheNode<K, V> {
        LFUCache.CacheNode<K, V> prev;
        LFUCache.CacheNode<K, V> next;
        K key;
        V value;
        LFUCache.CacheDeque owner;

        CacheNode() {
        }

        CacheNode(final K key, final V value) {
            this.key = key;
            this.value = value;
        }

        static <K, V> LFUCache.CacheNode<K, V> withdrawNode(final LFUCache.CacheNode<K, V> node) {
            if (node != null && node.prev != null) {
                node.prev.next = node.next;
                if (node.next != null) {
                    node.next.prev = node.prev;
                }
            }

            return node;
        }
    }
}

数据结构
在这里插入图片描述
测试

public class TestLFUCache {

    private static LFUCache<String, Integer> cache = new LFUCache<String, Integer>(3,0);

    public static void main(String[] args) {
        cache.put("k1",1);
        cache.get("k1");
        cache.put("k2",2);
        cache.get("k2");
        cache.put("k3",3);
        cache.put("k4",4);
        cache.put("k5",5);
        cache.put("k6",6);

        System.out.println(cache.get("k1"));
        System.out.println(cache.get("k2"));
        System.out.println(cache.get("k3"));
        System.out.println(cache.get("k4"));
        System.out.println(cache.get("k5"));
        System.out.println(cache.get("k6"));
    }
}

结果
结果
CacheDeque链表数组相当于给访问过的值计数，每访问过一次就移动到下一个下标处。

小舟~
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python实现LRU算法的2种方法
12-23
它的使用场景是：在有限的空间中存储对象时，当空间满时，会按一定的原则删除原有的对象，常用的原则（算法）有LRU，FIFO，LFU等。在计算机的Cache硬件，以及主存到虚拟内存的页面置换，还有Redis缓存系统中都用到了...
python-memoization：一个强大的Python缓存库，具有TTL支持和多种算法选项
01-30
mark: LRU（最近最少使用）作为缓存算法 :check_mark: :check_mark: LFU（最不常用）作为缓存算法没有支持 :check_mark: FIFO（先进先出）作为缓存算法没有支持 :check_mark: 新缓存算法的可扩展性没有支持 :check_m
昨天面试被问到的 缓存淘汰算法FIFO、LRU、LFU及Java实现
万猫学社
12-21 3711
缓存淘汰算法 在高并发、高性能的质量要求不断提高时，我们首先会想到的就是利用缓存予以应对。 第一次请求时把计算好的结果存放在缓存中，下次遇到同样的请求时，把之前保存在缓存中的数据直接拿来使用。 但是，缓存的空间一般都是有限，不可能把所有的结果全部保存下来。那么，当缓存空间全部被占满再有新的数据需要被保存，就要决定删除原来的哪些数据。如何做这样决定需要使用缓存淘汰算法。 常用的缓存淘汰算法有：FIFO、LRU、LFU，下面我们就逐一介绍一下。 FIFO FIFO，First In First Out，先进先出
常见的缓存淘汰算法
m0_70734549的博客
11-21 512
常见的缓存淘汰算法
缓存算法篇其一-----FIFO(先入先出)
weixin_71583566的博客
09-02 1875
FIFO先入先出缓存设计模式
常用淘汰算法
qq_39078390的博客
03-29 562
常用的淘汰算法
手写缓存之FIFO算法
m0_72106802的博客
09-01 628
我们都知道为了减轻数据库的访问压力，有一个很好的办法就是添加本地缓存或者分布式缓存，那么大家了解缓存都有哪几种算法吗？我为大家介绍其中的一种算法——FIFO先进先出算法！这种算法的缺点在于：FIFO算法对于一些内存中访问频率比较高，但是放入的时间又比较早的对象而言，命中率会比较率。所以这种算法使用的越来越少了，近些年比较流行的缓存算法为Lru算法，等我完全吃透Lru算法再来为大家讲解哦！
一个强大的Python 缓存库，具有 TTL 支持和多种算法选项
06-08
LRU（最近最少使用）作为缓存算法 LFU（最不常用）作为缓存算法 FIFO（先进先出）作为缓存算法 新缓存算法的可扩展性 TTL（生存时间）支持 支持不可散列的参数（字典、列表等） 自定义缓存键 按需部分缓存清除 遍历...
基于内容价值的缓存替换策略
01-19
缓存替换机制是内容中心网络的重要研究问题之一，考虑到缓存空间的有限...仿真结果表明，相比于传统替换算法 LRU、LFU 和 FIFO，本文提出的方案有效地提升了网络节点的内容缓存命中率，降低了用户获取内容的平均跳数。
PLC缓存：持久耐用的SSD缓存，用于基于重复数据删除的主存储
04-26
不幸的是，由经典缓存算法（例如FIFO，LRU和LFU）引起的频繁数据更新不可避免地减慢了SSD的I / O处理速度，同时大大缩短了SSD的寿命。 为了解决这个问题，我们提出了一种新的方法-PLC缓存-可以大大提高I / O性能...
【算法系列】淘汰算法之FIFO
tanpenggood
09-17 812
淘汰算法之FIFO (Fist in first out) 先进先出。
缓存淘汰算法(LFU LRU FIFO)及进程的状态和转换
最新发布
m0_53975470的博客
08-15 296
挂起等待态→挂起就绪态：引起进程等待的事件发生之后，相应的挂起等待态进程将转换为挂起就绪态挂起就绪态→就绪态：当内存中没有就绪态进程，或者挂起就绪态进程具有比就绪态进程更高的优先级，系统将把挂起就绪态进程转换成就绪态。运行态→挂起就绪态：当一个具有较高优先级的挂起等待态进程的等待事件结束后，它需要抢占 CPU，而此时主存空间不够，从而可能导致正在运行的进程转化为挂起就绪态。就绪态→挂起就绪态：操作系统根据当前资源状况和性能要求，也可以决定把就绪态进程对换出去成为挂起就绪态。即使这时CPU空闲也不能运行。
太厉害了，这款开源类库可以帮你简化每一行代码
代码界的扛把子
04-13 474
“黑铁时代”读者群里有个小伙伴感慨说，“Hutool 这款开源类库太厉害了，基本上该有该的工具类，它里面都有。”讲真的，我平常工作中也经常用 Hutool，它确实可以帮助我们简化每一行代码，使 Java 拥有函数式语言般的优雅，让 Java 语言变得“甜甜的”。 但是呢，群里还有一部分小伙伴表示还不知道这个开源类库，第一次听说。所以我决定写一篇文章普及下，毕竟好的轮子值得推荐啊。 Hutool 的作者在官网上说，Hutool 是 Hu+tool 的自造词（好像不用说，我们也能猜得到），“Hu”用
LFU Cache
zslngu的博客
03-13 439
24. LFU Cache 中文English LFU (Least Frequently Used) is a famous cache eviction algorithm. For a cache with capacity k, if the cache is full and need to evict a key in it, the key with the lease frequ...
三种常见的缓存过期策略LFU，FIFO，LRU说明
热门推荐
沛哥儿的专栏
05-09 1万+
缓存实现的过程以及淘汰旧页面的机制不同，所以会有不同缓存调度方法，就常见的就是FIFO，LRU，LFU缓存过期策略。 1.FIFO（First In First out）：先见先出，淘汰最先近来的页面，新进来的页面最迟被淘汰，完全符合队列。 2.LRU（Least recently used）:最近最少使用，淘汰最近不使用的页面 3.LFU（Least frequently used）: 最...
算法----LFU缓存
大魔王
04-06 1209
实现最不经常使用（LFU）缓存算法设计并实现数据结构。 它应该支持以下操作：get和put。 get(key)- 如果键存在于缓存中，则获取键的值（总是正数），否则返回 -1。 put(key, value)- 如果键不存在，请设置或插入值。当缓存达到其容量时，则应该在插入新项之前，使最不经常使用的项无效。在此问题中，当存在平局（即两个或更多个键具有相同使用频率）时，应该去除 最近 ...
关于FIFO（页面淘汰算法）和LRU（最近最少使用算法）详细说明
qq_38680137的博客
09-16 1万+
举例说明：例如在一个虚存系统中，进程的内存空间为3页，已开始内存为空，有以下访问序列：2,3,2,1,5,2,4,5,3,2,5,2。分别用以上两种方法分别计算缺页次数。 A：使用FIFO（页面淘汰算法） FIFO:先进先出，也就是， 先调2（缺） 内存为2. 调3（缺） 内存2.3. 调2（不缺）内存2.3 调1（缺）内存2.3.1 调5（缺）内存5.3.1（因为先进先出，所以替换...
数据结构与算法 / LRU 缓存淘汰算法
布袋和尚
11-17 235
一、诞生原因 缓存是一种提供数据读取性能的技术，在硬件设计、软件开发中有广泛的应用，比如常见的 CPU 缓存，DB 缓存和浏览器缓存等。但是缓存的大小是有限的，需要一定的机制判断哪些数据需要淘汰，即：移出缓存，从而保证缓存中的数据始终是常用的。常用的机制里面包括 LRU 缓存淘汰算法。 二、设计原则 全称：LeastRecently Used 如果一个数据在最近一段时间没有被访问到，那么在将来它被访问的可能性也很小。所以淘汰的数据应该是许久没有访问到的数据。 三、所用的数据结构 双向链表：用于.
缓存淘汰算法--LRU算法
学一次的博客
05-05 2215
LRU（Least recently used，最近最少使用）算法根据数据的历史访问记录来进行淘汰数据，其核心思想是“如果数据最近被访问过，那么将来被访问的几率也更高”。详细算法实现如下：
FIFO、LRU、LFU、OPT算法
04-25
分别是什么？它们在什么场景下会被使用到？ 回答： FIFO，即先进先出。对于缓存的替换算法而言，会将最早进入缓存的页替换出去，经常被用来实现页面置换算法。 LRU，即最近最少使用。该算法将在一段时间内没有被访问的页面替换出去，以保留最近最活跃的页面，从而降低缓存的命中率。也常被用于页面置换算法的实现中。 LFU，即最近最少使用。该算法标记并替换使用频率最低的页面，从而确保缓存中总是包含最活跃的页面。通常用于某些高性能缓存系统的实现。 OPT，即最佳置换算法。该算法根据未来的使用情况来替换缓存中的页面，以保持未来最大的缓存命中率。然而，实现该算法需要对未来的访问情况进行预测，因此一般不会被广泛使用。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值