LFU LRU和TinyLFU

最新推荐文章于 2025-01-30 10:09:16 发布
最新推荐文章于 2025-01-30 10:09:16 发布
阅读量844 收藏 2
点赞数
文章标签： 缓存 链表 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/define_us/article/details/122528215
版权

LFU

Least Frequently Used。在数据访问随时间概率不变时，这种缓存的命中率是最高的。而且LFU的成本也是最高的。

在这里插入图片描述

LRU

依赖于“时间局部性”的一种替代LFU的缓存方案叫做LRU，LRU中最近被访问的数据项都会被插入缓存，而当缓存满时，最久未被访问的会被淘汰。相比于LFU，LRU的性能会更高，而且自动适应数据的时间局部性，并且可以应对数据的突发流量。但是在实际的场景中，LRU需要更大的缓存空间，才能和LFU达到相同的缓存命中率。

LRU的典型实现如下
在这里插入图片描述
对于访问的节点，移送到/建立在链表开头。容量不足的时候，淘汰尾指针对应的节点。

SLRU

SLRU cache is divided into two segments, a probationary segment and a protected segment. Lines in each segment are ordered from the most to the least recently accessed. Data from misses is added to the cache at the most recently accessed end of the probationary segment. Hits are removed from wherever they currently reside and added to the most recently accessed end of the protected segment. Lines in the protected segment have thus been accessed at least twice. The protected segment is finite, so migration of a line from the probationary segment to the protected segment may force the migration of the LRU line in the protected segment to the most recently used (MRU) end of the probationary segment, giving this line another chance to be accessed before being replaced. The size limit on the protected segment is an SLRU parameter that varies according to the I/O workload patterns. Whenever data must be discarded from the cache, lines are obtained from the LRU end of the probationary segment

SLRU被分为两个段，试用段和保护段。新数据会被加到试用段里。如果试用段或者保护段的数据再次被命中，那么数据会被加入到保护段的头部。保护段的大小是有限的。如果需要清除数据，那么数据会从保护段的末尾开始清除。

TinyLFU

在这里插入图片描述
大概的思路就是，新增一个新的元素时，判断使用该元素替换一个旧元素，是否能够提高缓存命中率。为了做到这一点，tinyLFU需要维护相当长的一段历史时期内数据项访问的频率统计信息。为了做到这一点，我们使用了CBF(计数布隆过滤器)。
在这里插入图片描述

Window-TinyLFU


实际上就是结合了LRU和LFU

define_us
关注
【字节跳动面试100题精讲】实现一个 LRU（最近最少使用）缓存
AI天才研究院
09-23 684
LRU（Least Recently Used）缓存是一种常用的缓存淘汰算法，它的核心思想是"最近使用的数据在未来被使用的可能性更大"。在计算机系统中，缓存是一种重要的性能优化技术，而LRU算法则是众多缓存淘汰策略中的一种。当缓存满时，优先淘汰最久未使用的数据。每次访问数据时，将该数据移到缓存队列的头部。需要在O(1)时间复杂度内完成插入、查找和删除操作。理解LRU缓存的背景和特点，有助于我们更好地设计和实现这一算法。
阅读 redis 源码，学习缓存淘汰算法 W-TinyLFU
duan18888的博客
05-21 372
所有 IT 从业者都接触过缓存，一定了解基本工作原理，业界流行一句话：缓存就是万金油，哪里有问题哪里抹一下。那他的本质是什么呢？ 上图代表从 cpu 到底层硬盘不同层次，不同模块的运行速度，上层多加一层 cache, 就能解决下层的速度慢的问题，这里的慢是指两点：IO 慢和 cpu 重复计算缓存中间结果 但是 cache 受限于成本，cache size 一般都是固定的，所以数据需要淘汰，由此引出一系列其它问题：缓存一致性、击穿、雪崩、污染等等，本文通过阅读 redis 源码，学习主流淘汰算..
TinyLFU: A Highly Efficient Cache Admission Policy
01-16 1081
缓存是计算机科学中可以提高系统性能的最基本、最有效的一种方法之一。当完整的数据不适合全部缓存时，通过将一小部分数据存放到更快、更接近应用程序的内存中来提高性能。缓存可以提高性能的最直观原因在于数据的访问都表现出相当程度的“局部性”。更正式的表征这种“局部性”的方式，是通过概率分布来描述所有可能的数据项访问频率，在许多计算机科学的领域内，这种概率都表现出高度偏斜，也就是说少数的数据项会比其他数据项更可能被访问。并且在非常多的场景中，访问模式和概率分布会随着时间而变化，这种现象被称为“时间局部性”。 当访问一
缓存算法-FIFO/LRU/LFU/W-TinyLFU
l_dongyang的博客
09-19 4478
一、概况 《Caffeine入门使用》一文中介绍了当下性能比较好且正在流行的缓存组件Caffeine Cache，一个缓存组件是否好用，其中一个重要的指标就是他的缓存命中率，而命中率又和缓存组件本身的缓存数据淘汰算法息息相关的，本文意在讲解一些业界内常见的页面置换算法，以及在详细的介绍下Caffeine Cache的W-TinyLFU算法，以便于更好的理解缓存组件。 二、讲解 2.1 FIFO FIFO（First in First out）先进先出。可以理解为是一种队列的实现 算法：最先进来的数据，被认为
w-tinyLFU
qq_25622107的博客
08-23 3995
缓存设计是个基础架构领域里的重要话题，本号之前也有谈论过相关话题，点击原文可以看之前的介绍。   近日，HighScalability网站刊登了一篇文章，由前Google工程师发明的W-TinyLFU——一种现代的缓存。那么，什么缓存设计能够被称作是“现代”的呢？   当数据的访问模式不随时间变化的时候，LFU的策略能够带来最佳的缓存命中率。然而LFU有两个缺点：首先，它需要给每个记录项维...
论文《TinyLFU: A Highly Ecient Cache Admission Policy》阅读笔记
weixin_34060741的博客
08-21 983
1. Introduction LFU的局限： LFU实现需要维护大而复杂的元数据（频次统计数据等） 大多数实际工作负载中，访问频率随着时间的推移而发生根本变化（这是外卖业务不适合朴素LFU的根本原因） 针对LFU的问题，已经存在了一些LFU的替代或优化方案，例如WLFU（Window LFU）： 老化机制 限制采样为：最后W次访问...
Caffeine的Window TinyLfu算法分析
snail-jie的博客
06-17 1782
概括 通过put操作将数据放入data属性中（ConcurrentHashMap） 创建AddTask任务，放入(offer)写缓存：writeBuffer 从writeBuffer中获取任务，并执行其run方法,追加记录频率：frequencySketch().increment(key) 往window区写入数据 W-TinyLFU 整体设计 本部分参考了泥瓦匠BYSocket的文章，文章链接：https://jishuin.proginn.com/p/763bfbd358a0 判断一个缓存的好坏
高性能缓存-Caffeine
xjh19970715的博客
05-11 571
W-TinyLFU 频率记录的核心 LRU与LFU的对比 LRU(Least recently used,最近最少使用) 算法根据数据的历史访问记录来进行淘汰数据。 LFU(Least frequently used,最近最不常使用)算法根据一段时间数据的历史访问记录来进行淘汰数据。 试想一下在0-10分钟内A数据访问量为1000，B数据访问量为20，而在10-20分钟的时候，B访问量为500，而...
Java实现LFU缓存策略实战
最新发布
孤独的狼
01-30 732
LFU与LRU稍有不同，LFU是根据数据被访问的频率来决定去留。尽管它考虑了数据的近期使用，但它不会区分数据的首次访问和后续访问，淘汰那些访问次数最少的数据。
从一道 LRU 算法题说到缓存淘汰策略
2401_84046895的博客
04-19 870
双向链表节点的类型的基本属性如下：/***//***//***//***/HashMap用来存储 key 值对应的节点，为的是快速定位 key 值在链表中的位置，我们都知道，这是因为HashMap的 get 方法的时间复杂度为 O(1)。而如果不借助 HashMap，那这个过程可就慢了。如果要想找一个 key，要从链表头或链表尾遍历才行。按上图的展示， head 是链表头，也是最长时间未被访问的节点，tail 是最近被访问的元素，假设缓存最大容量是 4。插入元素。
现代的缓存设计方案：Window-TinyLFU
凌桓丶的博客
03-27 2566
现代的缓存设计方案：Window-TinyLFu
缓存淘汰算法的实现与应用介绍(LRU,LFU)
dblinux
04-05 614
缓存淘汰算法的实现与应用介绍（LRU、LFU） 1. 梗概 LRU：时间；每次将访问的key放到链表的最前面，若需要删除一个key，则删除的是链表最末尾的节点。 LFU：频率；每访问一次key1，就给key1使用频率加一，频率越高，越排在链表的前面，越不容易被删除；若两个key访问频率一致，则最近访问的key排在前面。 缺点：LFU容易饿，若有一种情况：某一段时间某一个key被访问了很多次，但后面几乎不被访问，但还是占据着链表的前面位置 LRU：当存在热点数据时,LRU的效率很好,但偶发性的,周期性的批量操
postgres源码解析8 Slru缓冲池--2
Serendipity_Shy
07-19 601
Slru源码实现原理
openGauss SLRU及multixact缓存管理介绍
Resurgence_zc的博客
12-03 999
openGauss使用SLRU来管理事务相关日志的缓冲区，包括CLOG、CSNLOG、multixact log。SLRU是简化版的LRU，使用数组的方式存储元素，每次换入换出是会遍历数组找到lru count最小的buffer。
Caffeine 驱逐算法
l_dongyang的博客
03-13 1929
概况 在《Caffeine入门使用》一文中讲解了Caffeine基本使用方法以及功能分类描述和使用示例，在会使用以及了解使用模式的背景下，在《Caffeine基础源码解析》文中对caffeine的主流程进行源码分析，从原理看下Caffeine的设计和实现，从会使用到深理解，本文是Caffeine学习的最后一部分，也是它最重要的一部分，驱逐算法的实现，即W-TinyLFU算法在Caffeine中的实现。 算法 对于缓存组件，驱逐算法基本是标配，它是直接影响缓存组件命中率的重要因素，无论是基于服务的Redis组
LFU算法的详细介绍与实现
weixin_45746505的博客
07-12 2231
LFU算法的实现
探索Tiny LRU：高效缓存解决方案的精简之道
gitblog_00021的博客
06-13 370
探索Tiny LRU：高效缓存解决方案的精简之道 tiny-lruTiny LRU cache for Client or Server项目地址:https://gitcode.com/gh_mirrors/ti/tiny-lru 在现代web开发和后端架构中，缓存机制是提升应用性能的关键所在。今天，我们向您隆重介绍一个轻量级且功能强大的缓存库——Tiny LRU。这是一款专为客户端与服务器设计...
常用的缓存机制
牧竹子
02-16 1339
文章目录1. LRU （Least Recently Used）最近最少使用2. LFU （Least Frequently Used）最近最不常用使用页面置换3.比较LRU 和 LFU 的缺点TinyLFU统计频率Count–Min Sketch 算法保新机制Window特性淘汰策略（eviction policy）异步的高性能读写总结 1. LRU （Least Recently Used）最近最少使用 核心思想：如果数据最近被访问过，那么将来被访问的可能性也更高。 实现： 1） 新数据插入链表头
Redis精通系列——LFU算法详述(Least Frequently Used - 最不经常使用)
qq_39093474的博客
01-03 791
LRU有一个明显的缺点，它无法正确的表示一个Key的热度，如果一个key从未被访问过，仅仅发生内存淘汰的前一会儿被用户访问了一下，在LRU算法中这会被认为是一个热key。例如如下图，keyA与keyB同时被set到Redis中，在内存淘汰发生之前，keyA被频繁的访问，而keyB只被访问了一次，但是这次访问的时间比keyA的任意一次访问时间都更接近内存淘汰触发的时间，如果keyA与keyB均被Redis选中进行淘汰，keyA将被优先淘汰。
使用PriorityQueue实现LFU和LRU
05-14
LFU (Least Frequently Used) 和 LRU (Least Recently Used) 都是常见的缓存淘汰策略，它们可以用 PriorityQueue（优先队列）来实现。 LFU 的思想是，当缓存空间满时，淘汰掉最不经常使用的缓存。具体实现时，我们可以使用一个字典来记录每个缓存的访问次数，然后将缓存按照访问次数从小到大排序，淘汰访问次数最小的缓存。 LRU 的思想是，当缓存空间满时，淘汰最近最少使用的缓存。具体实现时，我们可以使用一个双向链表和一个字典来记录缓存的顺序和存储的位置。每当访问一个缓存时，将其移动到链表头部；当缓存空间满时，淘汰链表尾部的缓存。 下面是使用 PriorityQueue 实现 LFU 和 LRU 的 Python 代码示例： LFU: ```python import heapq class LFUCache: def __init__(self, capacity: int): self.capacity = capacity self.cache = {} self.freq = {} self.count = 0 def get(self, key: int) -> int: if key not in self.cache: return -1 self.freq[key] += 1 heapq.heapify(self.cache[key]) return self.cache[key][0] def put(self, key: int, value: int) -> None: if self.capacity == 0: return if key in self.cache: self.cache[key].append(value) self.freq[key] += 1 heapq.heapify(self.cache[key]) else: if self.count == self.capacity: min_freq = min(self.freq.values()) for k, v in self.freq.items(): if v == min_freq: del self.cache[k] del self.freq[k] break self.count -= 1 self.cache[key] = [value] self.freq[key] = 1 self.count += 1 ``` LRU: ```python class LRUCache: def __init__(self, capacity: int): self.capacity = capacity self.cache = {} self.head = Node(0, 0) self.tail = Node(0, 0) self.head.next = self.tail self.tail.prev = self.head def get(self, key: int) -> int: if key not in self.cache: return -1 node = self.cache[key] self._remove(node) self._add(node) return node.val def put(self, key: int, value: int) -> None: if key in self.cache: self._remove(self.cache[key]) node = Node(key, value) self.cache[key] = node self._add(node) if len(self.cache) > self.capacity: node = self.head.next self._remove(node) del self.cache[node.key] def _remove(self, node): node.prev.next = node.next node.next.prev = node.prev def _add(self, node): node.prev = self.tail.prev node.next = self.tail self.tail.prev.next = node self.tail.prev = node class Node: def __init__(self, key, val): self.key = key self.val = val self.prev = None self.next = None ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值