LRU 和 LFU 缓存算法解析与实践

最新推荐文章于 2025-04-23 12:58:57 发布
最新推荐文章于 2025-04-23 12:58:57 发布
阅读量982 收藏 7
点赞数 22
分类专栏： java 文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57836225/article/details/143246081
版权

目录

 

一、主题介绍

二、LRU 算法

三、LFU 算法

四、LRU 与 LFU 的比较

一、主题介绍

缓存是提高系统性能的重要技术手段，LRU（Least Recently Used，最近最少使用）和 LFU（Least Frequently Used，最不经常使用）是两种常见的缓存替换算法。它们在不同的场景下有各自的优势和适用范围。LRU 根据数据的最近访问时间来决定淘汰哪些数据，而 LFU 则依据数据的访问频率。了解它们的原理和实现方式对于优化系统性能，特别是在处理大量数据访问时非常关键。

二、LRU 算法

  1. 原理

    • LRU 算法认为最近被访问的数据在未来一段时间内更有可能被再次访问，因此当缓存空间满时，它会淘汰最近最少使用的数据。例如，在一个网页浏览器的缓存中，最近浏览过的页面更有可能被再次查看，而很久之前浏览过的页面则可以被替换掉以释放空间给新的页面数据。

  2. 实现方式

    • 通常可以使用双向链表和哈希表来实现 LRU 算法。双向链表用于维护数据的顺序，按照最近访问的时间顺序排列，头部是最近访问的数据，尾部是最近最少访问的数据。哈希表则用于快速查找数据在链表中的位置，以提高访问效率。
    • 当有数据被访问时，将其从链表中移除并插入到头部，表示它是最近被访问的。当需要淘汰数据时，直接删除链表尾部的数据。

  3. Java 代码示例

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

// 节点类，用于双向链表
class Node {
    int key;
    int value;
    Node prev;
    Node next;

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

// LRU缓存类
class LRUCache {
    private int capacity;
    private Map<Integer, Node> map;
    private Node head;
    private Node tail;

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

    public int get(int key) {
        if (map.containsKey(key)) {
            Node node = map.get(key);
            removeNode(node);
            addToHead(node);
            return node.value;
        }
        return -1;
    }

    public void put(int key, int value) {
        if (map.containsKey(key)) {
            Node node = map.get(key);
            node.value = value;
            removeNode(node);
            addToHead(node);
        } else {
            Node newNode = new Node(key, value);
            if (map.size() >= capacity) {
                Node lastNode = tail.prev;
                removeNode(lastNode);
                map.remove(lastNode.key);
            }
            addToHead(newNode);
            map.put(key, newNode);
        }
    }

    private void removeNode(Node node) {
        node.prev.next = node.next;
        node.next.prev = node.prev;
    }

    private void addToHead(Node node) {
        node.next = head.next;
        node.prev = head;
        head.next.prev = node;
        head.next = node;
    }
}

  1. Vue 3 + TS 前端使用场景示例
    假设在一个前端应用中，需要缓存一些频繁访问的用户数据。可以创建一个 LRU 缓存对象来存储这些数据，当用户切换页面或进行某些操作时，快速获取缓存中的数据，减少对后端的重复请求。

import { ref } from 'vue';

class VueLRUCache {
    private lruCache: LRUCache;

    constructor(capacity: number) {
        this.lruCache = new LRUCache(capacity);
    }

    getFromCache(key: string): any {
        const intKey = parseInt(key);
        const value = this.lruCache.get(intKey);
        if (value!== -1) {
            return value;
        }
        return null;
    }

    putInCache(key: string, value: any) {
        const intKey = parseInt(key);
        this.lruCache.put(intKey, value);
    }
}

// 在组件中使用
const userDataCache = new VueLRUCache(10); // 假设缓存容量为10

const userData = ref(null);
const userId = '123';

// 尝试从缓存中获取用户数据
const cachedData = userDataCache.getFromCache(userId);
if (cachedData) {
    userData.value = cachedData;
} else {
    // 如果缓存中没有，从后端获取数据（这里只是模拟，实际需要调用API）
    const fetchedData = { name: 'John Doe', age: 30 };
    userData.value = fetchedData;
    // 将数据放入缓存
    userDataCache.putInCache(userId, fetchedData);
}

  1. Python 代码示例（模拟 LRU 缓存操作）

from collections import OrderedDict

# LRU缓存类
class LRUCachePython:
    def __init__(self, capacity):
        self.capacity = capacity
        self.cache = OrderedDict()

    def get(self, key):
        if key in self.cache:
            value = self.cache.pop(key)
            self.cache[key] = value
            return value
        return -1

    def put(self, key, value):
        if key in self.cache:
            self.cache.pop(key)
        elif len(self.cache) >= self.capacity:
            self.cache.popitem(last=False)
        self.cache[key] = value

# 使用示例
lru_cache = LRUCachePython(3)
lru_cache.put(1, "value1")
lru_cache.put(2, "value2")
lru_cache.put(3, "value3")
print(lru_cache.get(1))  # 输出 "value1"，此时1被移到最前面
lru_cache.put(4, "value4")  # 容量满，删除最久未使用的2
print(list(lru_cache.cache.keys()))  # 输出 [1, 3, 4]

三、LFU 算法

  1. 原理

    • LFU 算法基于数据的访问频率来决定淘汰哪些数据。它会记录每个数据被访问的次数，当缓存空间满时，淘汰访问频率最低的数据。例如，在一个内容推荐系统中，那些很少被用户点击的文章或视频可以被替换掉，为更热门的内容腾出空间。

  2. 实现方式

    • 一种常见的实现方式是使用哈希表和多个桶（buckets）来实现。哈希表用于存储数据和对应的访问频率信息，每个桶代表一个不同的访问频率级别。数据按照访问频率分配到不同的桶中，当有新的数据被访问时，其访问频率增加，可能会从当前桶移动到更高频率的桶中。当需要淘汰数据时，从最低频率的桶中选择数据进行删除。

  3. Java 代码示例

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

// 节点类，用于链表
class Node {
    int key;
    int value;
    int frequency;
    Node prev;
    Node next;

    public Node(int key, int value) {
        this.key = key;
        this.value = value;
        frequency = 1;
    }
}

// 桶类，用于管理相同频率的节点
class Bucket {
    Node head;
    Node tail;

    public Bucket() {
        head = new Node(0, 0);
        tail = new Node(0, 0);
        head.next = tail;
        tail.prev = head;
    }

    // 添加节点到桶的头部
    public void addNode(Node node) {
        node.next = head.next;
        node.prev = head;
        head.next.prev = node;
        head.next = node;
    }

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

    // 是否为空桶
    public boolean isEmpty() {
        return head.next == tail;
    }
}

// LFU缓存类
class LFUCache {
    private int capacity;
    private Map<Integer, Node> map;
    private Map<Integer, Bucket> frequencyMap;
    private int minFrequency;

    public LFUCache(int capacity) {
        this.capacity = capacity;
        map = new HashMap<>();
        frequencyMap = new HashMap<>();
        minFrequency = 0;
    }

    public int get(int key) {
        if (map.containsKey(key)) {
            Node node = map.get(key);
            increaseFrequency(node);
            return node.value;
        }
        return -1;
    }

    public void put(int key, int value) {
        if (capacity == 0) return;
        if (map.containsKey(key)) {
            Node node = map.get(key);
            node.value = value;
            increaseFrequency(node);
        } else {
            if (map.size() >= capacity) {
                Bucket minBucket = frequencyMap.get(minFrequency);
                Node lastNode = minBucket.tail.prev;
                minBucket.removeNode(lastNode);
                map.remove(lastNode.key);
            }
            Node newNode = new Node(key, value);
            addToBucket(newNode);
            map.put(key, newNode);
            minFrequency = 1;
        }
    }

    private void increaseFrequency(Node node) {
        int oldFrequency = node.frequency;
        Bucket oldBucket = frequencyMap.get(oldFrequency);
        oldBucket.removeNode(node);
        node.frequency++;
        Bucket newBucket = frequencyMap.getOrDefault(node.frequency, new Bucket());
        newBucket.addNode(node);
        frequencyMap.put(node.frequency, newBucket);
        if (oldBucket.isEmpty() && oldFrequency == minFrequency) {
            minFrequency++;
        }
    }

    private void addToBucket(Node node) {
        Bucket bucket = frequencyMap.getOrDefault(1, new Bucket());
        bucket.addNode(node);
        frequencyMap.put(1, bucket);
    }
}

  1. Vue 3 + TS 前端使用场景示例（假设用于缓存频繁访问的页面组件数据）

import { ref } from 'vue';

class VueLFUCache {
    private lfuCache: LFUCache;

    constructor(capacity: number) {
        this.lfuCache = new LFUCache(capacity);
    }

    getFromCache(key: string): any {
        const intKey = parseInt(key);
        const value = this.lfuCache.get(intKey);
        if (value!== -1) {
            return value;
        }
        return null;
    }

    putInCache(key: string, value: any) {
        const intKey = parseInt(key);
        this.lfuCache.put(intKey, value);
    }
}

// 在组件中使用
const componentDataCache = new VueLFUCache(5); // 假设缓存容量为5

const componentData = ref(null);
const componentKey = 'component1';

// 尝试从缓存中获取组件数据
const cachedData = componentDataCache.getFromCache(componentKey);
if (cachedData) {
    componentData.value = cachedData;
} else {
    // 如果缓存中没有，从后端获取数据（这里只是模拟，实际需要调用API）
    const fetchedData = { name: 'Component Data', props: { someProp: 'value' } };
    componentData.value = fetchedData;
    // 将数据放入缓存
    componentDataCache.putInCache(componentKey, fetchedData);
}

  1. Python 代码示例（模拟 LFU 缓存操作）

from collections import defaultdict, OrderedDict

# LFU缓存类
class LFUCachePython:
    def __init__(self, capacity):
        self.capacity = capacity
        self.cache = {}
        self.frequency = defaultdict(OrderedDict)
        self.min_frequency = 0

    def get(self, key):
        if key in self.cache:
            value, freq = self.cache[key]
            del self.frequency[freq][key]
            if not self.frequency[freq]:
                del self.frequency[freq]
            freq += 1
            self.frequency[freq][key] = value
            self.cache[key] = (value, freq)
            if freq == 1:
                self.min_frequency = 1
            elif self.min_frequency == freq - 1 and not self.frequency[freq - 1]:
                self.min_frequency = freq
            return value
        return -1

    def put(self, key, value):
        if self.capacity == 0:
            return
        if key in self.cache:
            _, freq = self.cache[key]
            self.cache[key] = (value, freq)
            self.get(key)
        else:
            if len(self.cache) >= self.capacity:
                oldest_key = next(iter(self.frequency[self.min_frequency]))
                del self.cache[oldest_key]
                del self.frequency[self.min_frequency][oldest_key]
                if not self.frequency[self.min_frequency]:
                    del self.frequency[self.min_frequency]
            self.cache[key] = (value, 1)
            self.frequency[1][key] = value
            self.min_frequency = 1

# 使用示例
lfu_cache = LFUCachePython(3)
lfu_cache.put(1, "value1")
lfu_cache.put(2, "value2")
lfu_cache.put(3, "value3")
lfu_cache.get(1)
lfu_cache.put(4, "value4")  # 容量满，删除频率最低的2（假设1和3访问频率增加到2，2还是1）
print(lfu_cache.cache)  # 输出 {1: ('value1', 2), 3: ('value3', 2), 4: ('value4', 1)}

四、LRU 与 LFU 的比较

  1. 适用场景

    • LRU 适用于数据访问模式具有时间局部性的场景，即最近访问的数据更有可能被再次访问。例如，浏览器缓存页面、操作系统的内存管理等。
    • LFU 适用于数据访问模式具有频率局部性的场景，即经常被访问的数据更有可能被再次访问。比如，缓存热点数据、频繁使用的功能模块的缓存等。

  2. 优缺点

    • LRU 优点：
      • 实现相对简单，通常只需要维护一个数据链表和一个哈希表。
      • 对于那些访问模式具有明显时间局部性的数据，能够快速适应并保留最近常用的数据，提高缓存命中率。
    • LRU 缺点：
      • 可能会因为某些数据的偶尔频繁访问而将其他长期有用但近期未访问的数据淘汰，导致缓存抖动。
      • 对于访问频率相同但最近访问时间不同的数据，无法区分优先级，可能会不合理地淘汰一些数据。
    • LFU 优点：
      • 更准确地反映数据的使用频率，能够优先保留真正的热点数据，减少因偶尔频繁访问导致的缓存替换错误。
    • LFU 缺点：
      • 实现相对复杂，需要维护数据的访问频率信息以及不同频率的链表或桶结构。
      • 当数据的访问频率分布不均匀时，可能会导致某些低频但近期有用的数据过早被淘汰，因为它只关注频率而忽略了时间因素。

在实际应用中，需要根据具体的业务需求和数据访问模式来选择合适的缓存算法。有时候也可以结合两者的优点，采用一些改进的算法或者策略来优化缓存性能。例如，可以设置一个频率阈值，当数据的访问频率超过该阈值时，将其按照 LRU 算法进行管理，以兼顾时间局部性和频率局部性。或者在 LFU 算法中引入时间衰减因子，使较旧的高频数据有一定几率被淘汰，以避免数据过度老化在缓存中。

LRU和LFU 算法（页面置换算法）
热爱学习和钻研。
02-27 4万+
LRU和LFU的区别 LRU和LFU都是内存管理的页面置换算法。 LRU：最近最少使用(最长时间)淘汰算法（Least Recently Used）。LRU是淘汰最长时间没有被使用的页面。 LFU：最不经常使用(最少次)淘汰算法（Least Frequently Used）。LFU是淘汰一段时间内，使用次数最少的页面。 例子 假设LFU方法的时期T为10分钟，访问如下页面所花的时间正好为10分钟，内存块大小为3。若所需页面顺序依次如下： 2 1 2 1 2 3 4 ----------
图解缓存淘汰算法 LRU、LFU ｜ 最近最少使用、最不经常使用算法 ｜ go语言实现
m0_74825360的博客
03-02 839
无论是什么系统，在研发的过程中不可避免的会使用到缓存，而缓存一般来说我们不会永久存储，但是缓存的内容是有限的，那么我们如何在有限的内存空间中，尽可能的保留有效的缓存信息呢？那么我们就可以使用 LRU/LFU算法，来维持缓存中的信息的时效性。
LRU和LFU算法
qq_43325216的博客
09-26 4741
在redis的学习中，了解到了两种缓存清理算法，分别是LRU和LFU，在此针对这两种算法进行学习。
缓存算法：LFU与LRU的原理与实现
最新发布
weixin_42596214的博客
04-23 256
本文详细探讨了缓存中的两种核心算法：最少使用（LFU）和最近最少使用（LRU）。文章首先解释了缓存的基本概念，包括最大化命中率和最小化未命中率的重要性。接着，通过分析LFU和LRU两种缓存淘汰策略，揭示了它们如何优化数据检索效率以及它们在不同场景下的适用性。文章还提供了LFU和LRU算法的实现细节，包括数据结构和操作步骤，以及一个具体的代码示例来加深理解。
LRU算法和LFU算法
冯同学的博客
06-08 3109
LRU算法和LFU算法
LRU算法与LFU算法
m0_48847163的博客
01-23 4341
LRU算法 LRU是Least Recently Used的缩写，即最近最少使用算法，是操作系统中页面置换算法的一种，由于内存中存放的页数有限，所以将最近没有使用到的算法会移出内存。 LRU原理： LRU原理如下图所示： 它会将最近访问的节点放在前面，将最近没有访问的节点放在后面。如果缓存空间满了，就会将最后一个节点删掉，并将新的节点添加到首部。 Java实现 对于链式存储的结构，使用到的集合有ArrayList和LinkedList，而ArrayList底层是基于数组的，对元素的移动花费的时间复杂度较高
LRU、LFU
haoranhaoshi的博客
11-20 463
LRU，即：最近最少使用淘汰算法（Least Recently Used）。LRU是淘汰最长时间没有被使用的数据。 LFU，即：最不经常使用淘汰算法（Least Frequently Used）。LFU是淘汰一段时间内，使用次数最少的数据。 举例： 数据2 1 2 1 2 3 4，加入4时内存超过阈值。 根据LRU会淘汰1，因为1距离想加入4的时间点（也就是淘汰时间点）最长。 根据LFU会淘汰3，因为加入4前的这段时间里，3的使用次数最少。 LRU算法实现： LeetCode官方题...
LeetCode习题解析：掌握LRU和LFU缓存算法
LRU和LFU是计算机科学中用于管理缓存的常见算法，它们在内存和存储系统中用于高效地处理数据。 首先，LRU即最近最少使用（Least Recently Used）算法，是一种常用的页面置换算法，用于管理计算机的内存。LRU算法的...
缓存淘汰策略：LRU、LFU、FIFO 算法原理
Java Punk
02-18 6777
LRU、LFU、FIFO、Two queues（2Q）算法原理
常见缓存算法FIFO、LFU、LRU
在所有的事情背后，要有一颗坚定的的本心，要有一颗应对变革和提升自我的本心，世界瞬息万变，本心要坚持到底，保持学习，时刻复盘
07-24 1609
常见缓存算法FIFO、LFU、LRU
LRU与LFU
Sword52888的博客
04-25 1720
LRU（Least Recently Used，最近最少使用）算法和LFU（Least Frequently Used，最近最少使用）算法都是用来作为缓存淘汰机制，保证缓存空间的有效利用。
Golang实现LRU Cache
skh2015java的博客
02-25 676
146. LRU Cache 运用你所掌握的数据结构，设计和实现一个 LRU (最近最少使用) 缓存机制 。 实现 LRUCache 类： LRUCache(int capacity) 以正整数作为容量 capacity 初始化 LRU 缓存 int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。 void put(int key, int value) 如果关键字已经存在，则变更其数据值；如果关键字不存在，则插入该组「关键字-值」。当缓存容量达到.
两种常见的缓存淘汰算法LFU&LRU
热门推荐
jake_li的博客
02-13 1万+
1. LFU 1.1. 原理 LFU（Least Frequently Used）算法根据数据的历史访问频率来淘汰数据，其核心思想是“如果数据过去被访问多次，那么将来被访问的频率也更高”。 1.2. 实现 LFU的每个数据块都有一个引用计数，所有数据块按照引用计数排序，具有相同引用计数的数据块则按照时间排序。 具体实现如下：
LRU和LFU的区别
渴望，就奋力追寻...
03-11 6593
一、概念介绍 LRU和LFU都是内存管理的页面置换算法。 LRU，即：最近最少使用淘汰算法（Least Recently Used）。LRU是淘汰最长时间没有被使用的页面。 LFU，即：最不经常使用淘汰算法（Least Frequently Used）。LFU是淘汰一段时间内，使用次数最少的页面。 二、例子详解 假设LFU方法的时期T为
LRU和LFU
weixin_44484668的博客
02-24 446
LRU 根据题意，使用过的数据放在链表的尾部，容量满了就删除链表的头，使用的数据结构是LinkedHashMap。 因为一般都是存储key-value键值对，所以肯定首选map中的hashmap，但是hashmap中的entry是随机排序的，来一个数据，想放在链表最后，你以为放到最后，但是没有，所以不能做cache，所以使用他的子类LiknedHashMap。究其原因还是因为LinkedHashMap定义中加了一个before参数，即它底层实现是数组+双向链表+红黑树。 146. LRU 缓存(中等) c
redis LRU和LFU
只为成功找方法 不为失败找借口
06-10 413
前言 Redis缓存淘汰策略与Redis键的过期删除策略并不完全相同，前者是在Redis内存使用超过一定值的时候（一般这个值可以配置）使用的淘汰策略；而后者是通过定期删除+惰性删除两者结合的方式进行内存淘汰的。 这里参照官方文档的解释重新叙述一遍过期删除策略：当某个key被设置了过期时间之后，客户端每次对该key的访问（读写）都会事先检测该key是否过期，如果过期就直接删除；但有一些键只访问一次，因此需要主动删除，默认情况下redis每秒检测10次，检测的对象是所有设置了过期时间的键集合，每次从这个集合中
算法之LRU和LFU算法
sixingmiyi39473的博客
04-19 2183
在地址映射过程中，若在页面中发现所要访问的页面不在内存中，则产生缺页中断。当发生缺页中断时，如果操作系统内存中没有空闲页面，则操作系统必须在内存选择一个页面将其移出内存，以便为即将调入的页面让出空间。而用来选择淘汰哪一页的规则叫做**页面置换算法。**
redis淘汰策略内存算法
A___B___C的博客
02-26 369
1、LRU算法 LRU(Least Recently Used)，即最近最少使用，是一种缓存置换算法。在使用内存作为缓存的时候，缓存的大小一般是固定的。当缓存被占满，这个时候继续往缓存里面添加数据，就需要淘汰一部分老的数据，释放内存空间用来存储新的数据。这个时候就可以使用LRU算法了。其核心思想是：如果一个数据在最近一段时间没有被用到，那么将来被使用到的可能性也很小，所以就可以被淘汰掉...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值