mysql内存淘汰机制_LRU内存淘汰算法原理与应用

最新推荐文章于 2025-03-26 01:12:08 发布
最新推荐文章于 2025-03-26 01:12:08 发布
阅读量903 收藏 1
点赞数
文章标签： mysql内存淘汰机制
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_35607083/article/details/113718824
版权
LRU算法常用于内存淘汰策略，本文介绍了其在操作系统虚拟内存和Redis缓存中的应用。在MySQL内存不足时，LRU策略用于决定哪些数据被淘汰；Redis则结合惰性删除和定期删除，并提供了多种淘汰策略，包括volatile-lru。文章还探讨了LRU的实现，通过哈希表和双向链表保证高效操作。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

LRU背景介绍

LRU，全称Least Recently Used-最近最少使用，是一种内存淘汰算法，笔者最早接触到这个算法是在本科操作系统的课程上，讲到操作系统的虚拟内存页面置换的时候提到的。

这个经典内存淘汰算法也被很多其它地方使用，经常作为缓存的淘汰策略，缓存作为一种提升查询速度的手段，本身就是为了将持久化到硬盘上的数据中的热点部分加载到读取速度更快的内存中(局部性原理)，而内存肯定是加载不了磁盘中的全部数据的，那就涉及到如果加载到缓存时发现内存满了怎么办？需要从缓存中淘汰掉谁？于是很自然的会想到淘汰内存中最冷门的记录*，于是LRU算法定义了标记跟踪到这个最冷门数据的方法。

b9a3a6a66e07

手机后台也是一种LRU

操作系统中的LRU

虚拟内存

操作系统作为用户应用与硬件设备之间的代理人，有着屏蔽底层不同硬件逻辑的职责，例如内存条，

b9a3a6a66e07

内存条

对于用户应用程序来说，不应该由它来操心运行在的这台机器到底查了几个内存条、啥型号的、有多大内存，也不需要关注会不会读到其它应用的内存信息、会不会写到人家内存上导致数据错乱。而是由操作系统封装了这一切，操作系统的封装方式就是虚拟内存。

操作系统的这种封装底层硬件、为上层用户应用提供API接口的思想也是计算机领域的核心思想，即分层思想，每一层只做当前这一层的封装功能，屏蔽掉底层的异构特性后为上一层提供抽象的统一的API接口，学会抽象是程序员的核心思维，无论是操作系统、TCP/IP网络架构、Java的Spring容器，都是这种思想的体现。

操作系统的虚拟内存通过页表为硬件和用户应用之间提供了固定内存大小和隔离不同进程内存空间的功能，本文重点讨论固定内存大小的实现。操作系统屏蔽了底层硬件内存的大小，例如对于32位操作系统来说，不论你用多少G的内存条，进程可用的内存空间都是4G(用户态+核心态)，如果实际内存条根本没有这么大的时候，就只能在内存条中存放部分数据，其它的内存数据存储在磁盘中，这就涉及到谁留在内存，谁又该放在磁盘上的经典哲学问题。

b9a3a6a66e07

虚拟内存

虚拟内存与LRU

操作系统往往采用的就是LRU算法判断那些经常被访问的热点数据，把它们留在内存中，而将最近最少使用的内存数据淘汰到磁盘上。龙龙的奇妙比喻：想象你是一个皇帝，操作系统是一个太监，太监总管根据你翻牌子的历史行为预判你今晚找哪位嫔妃侍寝，后宫佳丽三千，皇上选择的耐心有限，于是太监总管将最近最少翻牌子的嫔妃直接移出牌子池了。

b9a3a6a66e07

翻牌子

其它页面置换(淘汰)算法

最佳置换算法(OPT)，太监总管能预知未来，知道哪个嫔妃将来永远不会被宠幸，直接将她们淘汰，但这是不可能的，所以作为淘汰算法的评价标准

先进先出置换算法(FIFO)，太监总管比较耿直，永远公平公正，严格按照嫔妃的先来后到放牌子

最少使用(LFU)置换算法，LRU关注每个嫔妃最后被临幸的时间，LFU关注每个嫔妃历史被宠幸的频率，例如华妃历史上天天被临幸，但是刚好最近一周不被临幸了，对于LRU来说可能会被淘汰，对于LFU来说可能会保留；甄嬛早期天天不被临幸，但是最近一周被皇帝看上了，如果太监总管使用LRU-甄嬛必定是放到第一位，如果使用LFU-甄嬛这个新宠可能还是上不了牌子池

emmm...所以显然LRU更得圣心啊。。。

redis与LRU

redis的过期时间淘汰方式

一般情况中redis作为缓存是通过Expire KEY_NAME TIME_IN_SECONDS命令给key设置一个固定的淘汰时间，key到期后redis通过惰性删除或定期删除将过期的key从内存中清理掉。

redis的惰性删除与定期删除：

redis的缓存过期处理策略有三种实现方案：

定时删除，每当给一个key设置expire的时候，都启动一个定时器，在key过期的时候立刻删除。优点是节省内存，到期立刻清理；缺点是浪费CPU时间做清理工作，创建了大量定时器，性能影响严重

惰性删除，每次get key的时候看看是否过期。优点和1刚好相反，节省CPU时间；缺点是可能有长期不读的key一直赖在内存，浪费内存(内存泄漏)

定期删除，1和2的方案折衷，自如阿姨定期打扫一次房间，1和2的优缺点都有

最终redis采用的是惰性删除和定期删除的结合。

redis的LRU

以上清理都是发生在redis内存充足的时候，对于已经过期的key进行清理。

redis作为一种数据缓存层而存在的时候，也会遇到上文中操作系统的场景，当越来越多数据被缓存时，如果内存不够用了怎么办，redis提供了六种淘汰方式

config set maxmemory-policy volatile-lru

maxmemory-policy 六种方式

volatile-lru：只对设置了过期时间的key进行LRU(默认值)

allkeys-lru ： 删除lru算法的key

volatile-random：随机删除即将过期key

allkeys-random：随机删除

volatile-ttl ： 删除即将过期的

noeviction ： 永不过期，返回错误

笔者使用模块中的LRU

笔者工作中使用的模块可以理解为封装了各个数据源的查询、筛选、分页、排序功能，对外暴露出简单的select xxx from view where ... 的语句，可以理解为对MySQL view视图概念的模仿，对外只提供只读的功能。因而该模块也对查询操作进行了内存缓存，而缓存的淘汰算法同样是采用了经典的LRU算法。

b9a3a6a66e07

笔者使用模块中的LRU

LRU的实现——双向链表+哈希表

LRU cache作为一种cache，put/get操作的时间复杂度要求是O(1)，因此需要采用哈希表来存储KV的映射关系。

同时需要有一种数据结构，支持将最近最新访问过的节点排在最前面 && 将最近最少访问的节点移除出去，当然可以采用在Node[]数组中记录Node.lastestVisitTime时间戳，然后移除的时候排个序，这样的话每次排序都需要O(logn)的快排耗时，为保证内存淘汰的时间复杂度也为O(1)，需要采用双向链表，讲最新访问的节点放在表头，同时将表尾的节点踢出去

综上，LRU的实现需要将哈希表与双向链表的数据结构进行组合，通过冗余的一层数据结构来优化put/get的性能。

LRU cache的结构图如下

b9a3a6a66e07

哈希表+双向链表

LRU cache的get操作流程动图演示

b9a3a6a66e07

LRU cache的get操作流程动图演示

LRU cache的put操作流程动图演示

b9a3a6a66e07

LRU cache的put操作流程动图演示

LRU cache的伪代码如下

class LRUCached:

哈希表 # key -> Node(key, value)

双向链表 # Node -> Node -> Node

capacity = 10 # 容量，超过大小按照LRU算法开始淘汰

def get(key):

if(key 不存在):

return -1

else:

将数据挪到双向链表的表头 # 调用一次put(key, value)

return 哈希表.get(key).value

def put(key, value):

Node node = new Node()

if(key 已存在):

双向链表.remove(哈希.get(key))

双向链表.addFirst(node)

else: # key不存在

哈希表.put(key, value)

双向链表.addFirst(node)

if(双向链表.size > capacity):

双向链表.removeLast()

哈希表.remove(双向链表的lastNode.key)

reference

薇同学
关注
【Android面试八股文】你能说说LRU算法的原理并简单实现一下LRU算法吗？
字节卷动
08-11 350
LRU是的缩写，这种算法认为最近使用的数据是热门数据，下一次很大概率将会再次被使用。而最近很少被使用的数据，很大概率下一次不再用到。当缓存容量满的时候，优先淘汰最近很少使用的数据。假设现在缓存内部数据如图所示：这里我们将列表第一个节点称为头结点，最后一个节点为尾结点。当调用缓存获取key=1的数据，LRU算法需要将 1 这个节点移动到头结点，其余节点不变，如图所示。然后我们插入一个key=8节点，此时缓存容量到达上限，所以加入之前需要先删除数据。
LRU算法及其变种算法原理分析
zmysang的博客
04-13 3952
这一篇主要介绍缓存替换算法LRU及其变种算法的实现原理。 LRU（Least Recently Used）算法 最近最少使用算法，核心思想是：最近使用的数据很大概率将会再次被使用。而最近一段时间都没有使用的数据，很大概率不会再使用。做法：把最长时间未被访问的数据置换出去。这种算法是完全从最近使用的时间角度去考虑的。 执行过程理解: 在缓存中查找客户端需要访问的数据 如果缓存命中，则将访问的数据...
mysql lru_聊聊缓存淘汰算法-LRU 实现原理
weixin_39992831的博客
01-27 471
前言我们常用缓存提升数据查询速度，由于缓存容量有限，当缓存容量到达上限，就需要删除部分数据挪出空间，这样新数据才可以添加进来。缓存数据不能随机删除，一般情况下我们需要根据某种算法删除缓存数据。常用淘汰算法有 LRU,LFU,FIFO,这篇文章我们聊聊 LRU 算法。LRU 简介LRU 是 Least Recently Used 的缩写，这种算法认为最近使用的数据是热门数据，下一次很大概率将会再次被...
MySQL实战45讲学习笔记----查询结果返回过程分析
大魔王
02-08 1726
全表扫描时，客户端查询服务端数据库中大量数据，查询结果是如何返回给客户端的。 全表扫描对server层的影响 mysql -h$host -P$port -u$user -p$pwd -e "select * from db1.t" > $target_file InnoDB的数据是保存在主键索引上的，所以全表扫描实际上是直接扫描表t的主键索引。这条查询语句由于没有其他的判断条件，...
10-MySQL的LRU算法优化
最新发布
ProSayJ的博客
03-26 1929
冷数据区域的缓存页会在加载后至少1秒钟才会根据访问情况考虑迁移到热数据区域。这样避免了短期访问就造成不必要的迁移，确保了缓存区域的稳定性和性能。这就是LRU链表冷热数据分离的一套机制。通过这些学习，我们已经深入理解了LRU链表的设计机制以及冷热数据分离的原理。冷数据区域的设计当数据页刚被加载到缓存中时，它会首先进入冷数据区域的链表头部。如果在加载后1秒内没有被访问，它会留在冷数据区域，成为冷数据。热数据区域的设计。
内存淘汰机制与算法
xdc1812547560的博客
09-09 2233
文章目录内存淘汰机制与算法Redis 最大运行内存查询最大运行内存内存淘汰策略内存淘汰策略分类修改 Redis 内存淘汰策略内存淘汰算法LRU 算法 内存淘汰机制与算法 而 Redis内存淘汰机制指的是，当Redis 运行内存已经超过 Redis 设置的最大内存之后，将采用什么策略来删除符合条件的键值对，以此来保障 Redis 高效的运行。 Redis 最大运行内存 只有在 Redis 的运行内存达到了某个阀值，才会触发内存淘汰机制，这个阀值就是我们设置的最大运行内存，此值在 Redis 的配置文件中可以找
数据库系列4：LRU在Mysql中的应用
纵横千里 捭阖四方 的专栏
04-08 438
一般涉及到缓存的地方都少不了LRU，传统的LRU可以用Map+链表实现 ，value存的是在链表中的地址。 首先，InnoDB使用了一个双向链表，LRU List.但是这个LRUlist放的不是data page，而是执行缓存也的指针。 如果写buffer pool的时候发现没有空闲页了，就要从Buffer pool中淘汰数据也，就根据LRU链表的数据来操作。 首先，InnoDB的数据页不是都是在访问的时候才缓存到BP里的，而是有一个预读机制，也就是访问某个page的数据的时候，相邻的一些page可能会很快
mysql innodb LRU算法理解
baijiu1的博客
04-12 3957
innodb的LRU链表是有新旧两个队列，所以和LRU算法的Twoqueues有些类似 当数据要缓存如LRU链表时，先把数据移动到历史访问队列的链表里 如果数据停留时间超过1S，那么就从历史访问队列里移动到热区域的LRU链表里，如果数据停留时间小于1S，那么就不会移动 移动时间是由innodb_old_blocks_time参数控制，innodb_old_blocks_pct参数负责控制旧...
MySQL LRU内存淘汰机制
Java架狗师知识框架速查表
06-09 873
MySQL使用了LRU淘汰算法，LRU也就是least recently use，最近最少使用。策略就是使用的缓存页就加到LRU链表的头部，只要修改或者查询过就会移到链表头部，最后淘汰LRU尾部的。
MySQL如何改进LRU算法
qq2904529388的博客
04-20 954
操作系统出于空间局部性原理（靠近当前被访问数据的数据，在未来很大概率会被访问到）所以当我们,读取一部分内容时,它旁边的内容也会被加载到内存中,同时如果文件读取内容小,那么预读机制也可以充分利用空间,将这一部分缺少的内存补充,为未来访问作准备什么是预读失效如果这些被提前加载进来的页并没有被访问，相当于这个预读工作是白做了，这就是预读失效。传统的 LRU 算法，就会把「预读页」放到 LRU 链表头部，而当内存空间不够的时候，淘汰掉末尾。
mysql缓存淘汰机制_Redis内存淘汰机制
weixin_28700411的博客
02-19 214
Redis内存淘汰指的是用户存储的一些key可以被Redis主动地从实例中删除，从而产生读miss的情况，那么Redis为什么要有这种功能？这就是我们需要探究的设计初衷，Redis最常见的两种应用场景为缓存和持久存储，首先要明确的一个问题是内存淘汰策略更适合于那种场景？是持久存储还是缓存？内存的淘汰机制的初衷是为了更好地使用内存，用一定的缓存miss来换取内存的使用效率。redis 官方提供的 c...
mysql lru_LRU Cache实现原理
weixin_27741699的博客
02-07 278
从今年四月份以来，博客有所停更，中间发生了很多事，有坏的，也有好的，主要还是自己懈怠了，不过生活还是回到了正轨。写了这么久的博客，个人感觉主要目的还是两个：一是对已经掌握的知识进行一个总结，通过文字的方式记录下来，这样自己的理解会更加深刻；二是在后续需要用到相关知识的时候，能够通过自己的博客能够回本溯源，快速回顾相关的知识点，个人感觉在面试之前不知道复习什么的时候，博客是一份非常好的资料。这次恢复...
mysql算法优化_LRU算法及其优化策略——Mysql篇
weixin_29109261的博客
01-28 526
在上一篇文章中，介绍了LRU算法在Redis之中的应用，本篇继续给各位道友介绍在Mysql的InnobDB引擎中，是如何使用LRU算法的。InnoDB缓冲池缓存池简介及内存结构首先来介绍下InnoDB的缓冲池，缓冲池简单来说就是一块内存区域，该区域内缓存着InnoDB访问存储在磁盘的数据和索引信息。缓冲池有两个作用，一是提高了大容量读取操作的效率，二是提高了缓存管理的效率。调配缓存池参数，使得经常...
Mysql——LRU链表
小志的博客
11-02 2163
目录一、LRU链表的概述二、LRU链表的处理逻辑三、LRU链表的优缺点四、预读的概述五、预读的分类（根据触发方式分类）六、造成Buffer Pool命中率低的原因七、Buffer Pool命中率低的解决方式八、对于简单LRU链表的缺点优化 一、LRU链表的概述 LRU = Least Recently Used（最近最少使用）； 由于缓冲区空间有限，如果满了，则需要把旧的移除掉，新的加进来； 把使用频繁的数据保留在缓存中，把使用频率低的数据移除； 用来记录缓冲页的被使用热度； Buffer Pool的缓冲
mysql lru_Mysql缓存-全表扫描过程、LRU算法
weixin_29602351的博客
01-27 308
在日常开发中，常因为分页查询的使用，或者SQL的语法问题导致的全表扫描，这带来的问题可能会有系统的OOM，频繁的GC，以及慢SQL，数据返回慢等问题。那么我们如果光从内存这个角度看这个全表扫描的问题，他是怎么样进行查询返回结果的呢？假设我的主机内存就几个G，但是全表的数据可能是它的几倍，那么机器的内存会直接用光吗？结合日常的开发工作，对大表做全表扫描，看来应该是没问题的(只看数据而言)。但是，这个...
MySQL LRU算法
zqcn504406312的博客
11-18 890
OLD和NEW区链表长度比默认为3:5 midpoint是NEW链表和OLD链表的分解线 数据块被用户SQL请求或innodb进程的read_head操作触发，首次被加入midpoint位置 如果数据块被用户请求获取，立即提升数据块到NEW区的最前面，如果是innodb的read_head操作，延迟或不提升数据块到NEW区的最前面 数据库（自身后台维护）操作，不会引起数据块在链表内部的移动
mysql lru算法_INNODB缓冲池LRU算法
weixin_30946627的博客
02-10 425
LRU(least recently used ，即最近最少使用)算法是数据库中缓冲池的管理算法，将数据库的缓冲池作为一个列表使用，该列表分为两个部分：NewSublist，OldSublist。频繁使用的页在列表的‘新端’，而使用最少的页面在列表的‘旧端’。Innodb中，同样使用LRU算法进行管理，与传统的LRU算法不同，Innodb存储引擎引入mitpoint位置(图中剪头所指)，默认...
mysql lru_浅析MySQL的lru链表
weixin_32770297的博客
01-19 1217
一、简述传统的LRU链表LRU：Least Recently Used相信大家对LRU链表是不陌生的，它算是一种基础的数据结构吧，而且想必面试时也被问到过什么是LRU链表，甚至是让你手写一个LRU链表。想必你已经知道了MySQL的Buffer Pool机制以及MySQL组织数据的最小单位是数据页。并且你也知道了 数据页在Buffer Pool中是以LRU链表的数据结构组织在一起的。其实所谓的LRU...
MySQL LRU算法(冷热数据分离)
张伯毅的专栏
05-05 904
MySQL中使用的InnoDB存储引擎采用了一种特别的最近最少使用（LRU, Least Recently Used）算法来管理其Buffer Pool中的页（包括数据页和索引页）。Buffer Pool是InnoDB用来缓存数据，以减少磁盘I/O操作的内存区域。正确地管理这个缓存对于数据库的性能至关重要，而LRU算法就是用来决定哪些页应该保留在Buffer Pool中，哪些页应该被替换出去的一种策略。因为mysql的预读机制, 预读大量无用的数据. 可能会导致缓存失效, 降低性能…
cache的LRU算法原理
03-21
<think>好的，用户想了解LRU缓存淘汰算法的工作原理和实现机制。我需要先回顾一下LRU的基本概念，然后逐步解释它的原理和实现方式。 首先，LRU的全称是Least Recently Used，也就是最近最少使用算法。根据引用[1]和[3]，它的核心思想是淘汰最近最少被访问的数据。这里的关键点在于“时间局部性”原理，也就是最近被访问过的数据很可能在未来会被再次访问。 接下来，我需要解释LRU的工作原理。通常会提到缓存空间有限，当新数据加入时，如果缓存已满，就需要淘汰最久未使用的数据。这个过程可以通过维护一个数据结构来跟踪访问顺序。常见的实现方式有哈希表加双向链表，或者使用有序字典。引用[2]提到双向链表的实现，这可能是因为链表可以快速调整节点的位置，而哈希表提供快速查找。 然后要讨论具体的实现机制。比如，当访问一个数据时，如果它已经在缓存中，需要将其移动到最近使用的位置（比如链表头部）。如果不在缓存中，则需要将其加入，如果缓存已满，则删除链表尾部的节点。这里需要结合引用中的信息，确保正确引用来源。 用户可能还关心实际应用场景，比如数据库缓存、浏览器缓存等，但根据问题，重点应放在原理和实现上。需要检查是否有其他引用内容需要整合，比如引用[3]提到的LRU原理的时间局部性，这一点应该在解释算法思想时强调。 最后，生成相关问题时要围绕LRU的扩展，比如与其他算法比较、实现方式、应用场景等，确保问题与主题相关，并且基于已有的引用内容。例如，可以问LRU和FIFO的区别，或者如何用其他数据结构实现LRU。</think>### LRU缓存淘汰算法原理及实现机制 #### 核心思想 LRU（Least Recently Used）算法的核心是**淘汰最久未被访问的数据**。其原理基于**时间局部性假设**：如果一个数据最近被访问过，那么它在未来被再次访问的概率较高[^3]。缓存空间有限时，优先保留高频访问数据，移除“冷数据”。 #### 工作原理 1. **缓存访问**：当数据被访问（读取或写入）时，标记其为“最近使用”。 2. **缓存淘汰**：当缓存满且需要插入新数据时，淘汰最久未被访问的数据。 #### 实现机制 ##### 方法一：哈希表 + 双向链表 1. **数据结构**： - **双向链表**：按访问时间排序，头部为最近访问节点，尾部为最久未访问节点。 - **哈希表**：存储键与链表节点的映射，实现$O(1)$时间查找。 2. **操作流程**： - **访问数据**：若数据存在，将其移动到链表头部[^2]。 - **插入数据**： - 若缓存未满，直接插入链表头部。 - 若缓存已满，删除链表尾部节点，再插入新节点。 - **删除数据**：直接从链表尾部移除。 ```python class LRUCache: class Node: def __init__(self, key, val): self.key = key self.val = val self.prev = None self.next = None def __init__(self, capacity): self.cap = capacity self.map = {} self.head = self.Node(0, 0) self.tail = self.Node(0, 0) self.head.next = self.tail self.tail.prev = self.head def _add_to_head(self, node): node.next = self.head.next node.prev = self.head self.head.next.prev = node self.head.next = node def _remove_node(self, node): node.prev.next = node.next node.next.prev = node.prev def get(self, key): if key in self.map: node = self.map[key] self._remove_node(node) self._add_to_head(node) return node.val return -1 def put(self, key, value): if key in self.map: self._remove_node(self.map[key]) node = self.Node(key, value) self.map[key] = node self._add_to_head(node) if len(self.map) > self.cap: del_node = self.tail.prev self._remove_node(del_node) del self.map[del_node.key] ``` ##### 方法二：有序字典（OrderedDict） Python中可直接使用`collections.OrderedDict`，其特性为自动维护插入顺序： ```python from collections import OrderedDict class LRUCache: def __init__(self, capacity): self.cache = OrderedDict() self.cap = capacity def get(self, key): if key not in self.cache: return -1 self.cache.move_to_end(key) # 标记为最近使用 return self.cache[key] def put(self, key, value): if key in self.cache: self.cache.move_to_end(key) self.cache[key] = value if len(self.cache) > self.cap: self.cache.popitem(last=False) # 删除最久未使用的键 ``` #### 应用场景 - **数据库缓存**：如MySQL查询缓存。 - **浏览器缓存**：管理最近访问的页面资源。 - **CDN节点**：缓存热点内容，提升访问速度[^1]。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值