图解 LFU 缓存淘汰算法以及在 Redis 中的应用(附带个人完整代码实现)

文章目录

  • LFU 算法
    • 理论介绍
    • 算法实现
      • 数据结构
      • 查询操作
      • 插入/更新操作
  • Redis 缓存淘汰算法
    • 缓存污染难题
    • Redis LFU缓存淘汰策略

本篇博客的主要内容:

  • 以图解的方式,介绍 LFU 算法的一种实现;
  • 介绍 LFU 算法在 Redis 中的应用。

LFU 算法

理论介绍

最不常使用 (LFU Least Frequently Used) 算法是一种常用的缓存置换算法,旨在移除 访问频次最低 的缓存项。与常用的 LRU 算法不同,LFU 算法更加重视元素的访问频率,而非最近一次访问时间。

实现 LFU 淘汰算法的缓存需要满足如下规则:

  1. 缓存中键值对的数目不能超过容量 capacity
  2. get(key) 操作:如果键 key 存在于缓存,则返回该键;否则空值。
  3. put(key, val) 操作:如果 key 已经存在,变更其值;如果 key 不存在,插入键值对。当缓存达到其容量 capacity 时,则应该在插入新项之前,移除 最不经常使用 的键值对。如果存在两个或更多键具有相同的最小频率,应该去除 最近最久未使用(LRU) 的键值对。

解释下高亮部分:

  • 最不经常使用的键值对:使用频数最少的键,使用 get(key) 或 put(key, val) 访问键对都会增加键的频数。当一个键首次插入到缓存中时,它的使用计数器被设置为 1
  • 最近最久未使用的键值对:缓存中键的最小频数为 count_min,当需要淘汰缓存时,可能存在多个键的频数等于 count_min。对于这种情况,针对频数等于 count_min 的键值对,采用 LRU(最近最久未使用)算法淘汰。

算法实现

本节介绍如何设计 get、put 函数以 O(1) 时间复杂度运行 的 LFU 缓存。

数据结构

缓存中的键值对通过一个全局双向循环链表存储,链表节点 Node 的定义如下:

struct Node{int key;int val;Node* prev;Node* next;int count;Node(int k, int v): key(k), val(v), prev(nullptr), next(nullptr), count(1) {}Node(int k, int v, Node *p, Node *n): key(k), val(v), prev(p), next(n), count(1) {}
};
  • key、val:键值对的键与值
  • prev:前驱节点;
  • next:后继节点;
  • count:节点的访问次数,新节点插入时设置初始值 1。

缓存中使用字段 head 存储双向循环链表的头节点,头节点是 链表中频数最高的节点

Node *head = nullptr;

LFU 缓存是一个由多个 链表分段 拼装而成的双向循环链表,相同链表段中的节点频数相等。示意图如下:
双向循环链表



当一个频数 count 的节点被访问,频数将递增为 count + 1,我们需要在 O(1) 的时间将该节点频数 count 的链表分段移动到频数 count + 1 的链表分段头部

因此,需要一个哈希表 count2SegHead 维护频数count 到链 表分段头节点 的映射

unordered_map<int, Node*> count2SegHead;

示意图如下:
count2SegHead 哈希表



为了在 O(1) 时间复杂度通过 key 访问节点,需要使用哈希表 key2Node 维护 键key 到 节点 的映射

unordered_map<int, Node*> key2Node;

示意图如下:


查询操作

查询操作步骤如下:

  1. 通过哈希表 key2node 查询到指定键的节点 node;
  2. 将 node 节点从双向循环链表中移除;
  3. 节点频数为 count,找到 count + 1 的链表分段头节点 seg_head;
  4. 更新 node.count = count + 1,将 node 节点插入 seg_head 前,同时设置 count2SegHead[count + 1] = node,即设置 node 节点为频数 count + 1 的链表段头节点。

下面这副示意图展示了查询 key=8 节点的流程:

  1. 通过 key2Node 找到节点位置,key=8 节点的频数为 3。
  2. 从频数 3 的链表分段中移除 key=8 节点;
  3. 查询 count2SegHead 得到频数为 3+1=4 的链表分段头节点(key=3),将 key=8 节点的频数更新为 4,然后插入到 key=3 节点的前驱。
  4. 最后,更新 head 指针以及 count2SegHead[4] = node
    在这里插入图片描述

查询函数 getNode 代码实现如下:

#include "bits/stdc++.h"using namespace std;class LFUCache {struct Node{int key;int val;Node* prev;Node* next;int count;Node(int k, int v): key(k), val(v), prev(nullptr), next(nullptr), count(1) {}Node(int k, int v, Node *p, Node *n): key(k), val(v), prev(p), next(n), count(1) {}};unordered_map<int, Node*> key2Node;unordered_map<int, Node*> count2SegHead; // 频数到链表分段的映射int capacity;int size = 0;Node *head = nullptr; // 双向循环链表头节点// 将链表中的 node 节点移动到 newCount 链表段void moveNode(Node* node, int newCount) { // ------(1)auto nextNode = remove(node);node->count = newCount;if(count2SegHead.find(newCount) == count2SegHead.end())insert(node, nextNode);elseinsert(node, count2SegHead[newCount]);}// 将节点插入到链表段头节点 segHead 前, 同时维护 head 指针和 count2LinkedListvoid insert(Node* node, Node* segHead) {count2SegHead[node->count] = node;if(segHead == nullptr) {node->next = node->prev = node;head = node;return;}node->next = segHead, node->prev = segHead->prev;node->prev->next = node, node->next->prev = node;if(head->count <= node->count) head = node;}// remove 函数Node* remove(Node *node){// 循环链表中仅有node节点if(node->next == node){count2SegHead.erase(node->count);head = nullptr;return nullptr;}Node* next;// node 节点为 node->count 链表段的头节点if(count2SegHead[node->count] == node) {if(node->next->count == node->count)count2SegHead[node->count] = node->next;elsecount2SegHead.erase(node->count);next = node->next;} // node 不是链表段头节点else next = count2SegHead[node->count];node->prev->next = node->next, node->next->prev = node->prev;node->prev = node->next = nullptr;if(head == node) head = next;return next;}public:LFUCache(int cap) {this->capacity = cap;}Node* getNode(int key){if(key2Node.find(key) == key2Node.end()) return nullptr;auto node = key2Node[key];moveNode(node, node->count + 1); // ------(1)return node;}
};

moveHead(Node* node, int newCount):将循环链表中的节点 node 移动到频数为 newCount 的链表段头部。


moveHead 执行 remove(Node *node) 函数从双向循环链表中移除 node 节点:

  • 如果循环链表中只有 node 节点,将 head 设置为 nullptr,count2SegHead 哈希表移除频数为 node->count 的键值对;
  • 如果 node 为 node->count 链表段的头节点,考察 node->next 的频数:
    • 如果相等,将 node->next 设置为链表段新的头节点;
    • 如果不相等,说明 node 为该链表段的唯一节点,移除 node 后链表段也被移除,count2SegHead 移除 node->count 键值对。
  • 如果 node 不为链表段头节点,可以直接移除,无需维护 head 及 count2SegHead;
  • 返回值:node->count 链表段移除 node 后的头节点;如果链表段已移除,则返回该链表段的后继链表段头节点。
Node* remove(Node *node){// 循环链表中仅有node节点if(node->next == node){count2SegHead.erase(node->count);head = nullptr;return nullptr;}Node* next;// node 节点为 node->count 链表段的头节点if(count2SegHead[node->count] == node) {if(node->next->count == node->count)count2SegHead[node->count] = node->next;elsecount2SegHead.erase(node->count);next = node->next;} // node 不是链表段头节点else next = count2SegHead[node->count];node->prev->next = node->next, node->next->prev = node->prev;node->prev = node->next = nullptr;if(head == node) head = next;return next;
}

移除 node 节点后,使用 insert(Node* node, Node* segHead) 将 node 插入到链表段 segHead 的头部:

  • 将 node 设置为 node->count 链表段新头节点:count2SegHead[node->count] = node;
  • 如果 segHead 为 nullptr,说明全局链表为空,执行双向循环链表的初始化操作;
  • 如果 segHead 非空,将 node 插入到 segHead 的前驱。
  • 如果 node.count 操作计数大于等于当前头节点 head 的计数,将 node 设置为新的头节点。
    // 将节点插入到链表段头节点 segHead 前, 同时维护 head 指针和 count2LinkedListvoid insert(Node* node, Node* segHead) {count2SegHead[node->count] = node; // 设置为新的链表段头节点if(segHead == nullptr) {// segHead 为 null, 说明全局链表为空, 执行初始化操作node->next = node->prev = node;head = node;return;}// 双向链表插入操作node->next = segHead, node->prev = segHead->prev;node->prev->next = node, node->next->prev = node;// 如果 node 操作计数大于等于当前头节点的计数, 更新 headif(head->count <= node->count) head = node;}

插入/更新操作

插入/更新操作的步骤如下:

  1. 使用 getNode 查询键为 key 的节点;
  2. 如果节点存在,只需要更新 node.val 为 value 新值,频数更新、双向循环链表的维护由 getNode 函数完成。
  3. 如果节点不存在,则执行新节点插入操作,新节点的初始频数 count 等于 1;
    • 缓存大小等于容量,则淘汰缓存中频数最少的节点,如果频数最少的节点非唯一,淘汰最近一次访问时间最早(LRU)的节点。
    • 缓存大小小于容量,将节点插入到频数 1 的链表段头节点之前。
      还需要考虑到,当前不存在频数为 1 的节点,也即不存在频数为 1 的链表段。这种情况下,将新节点插入到 head 节点之前即可。
void put(int key, int value) {if(capacity <= 0) return;Node *node = getNode(key);if(node == nullptr) {// 键等于 key 的节点不存在, 插入新的节点if(size == capacity){// 容量已经达到上限, 淘汰频数最低的节点, 即 head.prevauto evict = head->prev;remove(evict);key2Node.erase(evict->key);delete evict;} else size++;// 新的节点, node = new Node(key, value, nullptr, nullptr);key2Node[key] = node;if(count2SegHead.find(1) == count2SegHead.end())// 如果不存在频数为 1 的链表段, 将新节点插入到head的前驱;insert(node, head);else // 如果存在频数等于 1 的链表段, 新节点插入到该链表段的头节点前insert(node, count2SegHead[1]);} else node->val = value; // 更新键等于 key 的节点值
}

下面,我用两个场景,带大家理解 LFU 缓存的插入操作:

场景1:插入节点后缓存大小(size=7) 未超出 容量capacity(7),新节点(key=4) 插入到频数等于 1 的链表段前,成为该链表段的头节点。示意图如下:

在这里插入图片描述

场景2:插入节点后缓存大小(size=7) 超出 容量capacity(6),先 淘汰操作频数最小的节点 (key=7),此时频数为 1 的链表段将被移除,新节点(key=4) 插入到头节点(key=3) 之前。示意图如下:


Redis 缓存淘汰算法

Redis 中实现了基于 LFU 的缓存淘汰策略:volatile-lfu 和 allkeys-lfu。在介绍该策略之前,我们先了解下 缓存污染 的概念。

缓存污染难题

缓存污染 是指 访问很少的数据 在服务完访问请求后还继续 留存在缓存中,造成缓存空间的浪费。

缓存污染一旦变得严重后,有大量不再访问的数据滞留在缓存中,往缓存中写入新数据时需要先把数据逐步淘汰出缓存,引入额外的操作时间开销。


如何解决缓存污染问题?

  • volatile-ttl 策略:如果业务应用在设置过期时间时,明确知道数据的访问情况(即数据的时效性),Redis 按照数据的剩余最短存活时间淘汰数据,可以避免缓存污染。
  • volatile-lru、all-lru:淘汰候选数据集中,lru 字段最小(最近一次访问时间最久的数据。

LRU 方案的缺陷:只考虑了数据的访问时间,没有考虑数据的访问频数,在处理 扫描式单次查询操作 时,无法解决缓存问题!


幸运的是,Redis 从 4.0 版本开始增加了 LFU 淘汰策略:从 数据访问的时效性数据访问次数 两个角度筛选出需要淘汰的数据。


Redis LFU缓存淘汰策略

在实现 LRU 算法时,Redis 使用 RedisObject 结构来保存数据的;该结构的 lru 字段记录数据最近一次访问的时间戳。实现 LFU 算法时,将原来 24bit 的 lru 字段,进一步拆分成两个部分:

  • ldt 值:lru 字段的前 16bit,表示数据的访问时间戳;
  • counter 值:lru 字段的后 8bit,表示数据的访问次数。

Redis使用LFU策略淘汰数据时,选择 lru 字段最小的数据进行淘汰。等价于 优先淘汰访问次数少的数据,访问次数相等则淘汰时间戳最小 的数据。

注意:count 为计数器的值,初始默认为 5 而不是 1。如果初始值为 1,刚被写入缓存的数据可能会因为使用次数太少而立即被淘汰。


counter 值 8bits,最大值 255,如果采用线性增加的方式 counter 很快就会达到上限,Redis 就不能很好筛选访问 1000次 和 10000 次的数据。因此,Redis 采用了非线性的频数更新策略:

p = 1 c o u n t × l f u _ l o g _ f a c t o r + 1 p=\frac{1}{count \times {lfu\_log\_factor} + 1} p=count×lfu_log_factor+11

每次缓存的数据被访问, counter 加 1 的概率等于 p p p,源码如下:

double r = (double)rand()/RAND_MAX;
...
double p = 1.0/(baseval*server.lfu_log_factor + 1);
if (r < p) counter++;   

通过设置 lfu_log_factor 配置项,可以控制计数器的增加速度,避免 counter 值过快到达255。下图所示,当 lfu_log_factor 等于100时,小于10M 的数据能被区分出来。


一般可以将 lfu_log_factor 取值为 10,已经足够区分1k、1w、10w的数据访问量。



counter的衰减机制

LFU 策略使用衰减因子配置项 lfu_decay_time 来控制访问次数的衰减。

  1. LFU 策略会计算当前时间和数据最近一次访问时间的差值,并把这个差值换算成以分钟为单位。
  2. 然后,LFU 策略再把这个差值除以 lfu_decay_time 值,所得的结果就是数据 counter 要衰减的值。
    假设 lfu_decay_time 取值为 1,如果数据在 N 分钟内没有被访问,那么它的访问次数就要减 N。

lfu_decay_time 取值更大,那么相应的衰减值会变小,衰减效果也会减弱。如果业务应用中有短时高频访问的数据的话,建议把 lfu_decay_time 值设置为 1,在数据不被访问后,可以 迅速衰减访问次数,从缓存中淘汰出去,避免缓存污染。


总结:LFU 淘汰策略对于扫描式单次数据读取操作时,虽然仍然会频繁写缓存,但可以 避免访问次数高的热点数据因为最近一次访问时间较早而被淘汰,提升了缓存的命中率。

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/762764.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

人工智能驱动客服行业变革:迈向智能化、自动化与数据驱动的新纪元

在科技浪潮的推动下&#xff0c;人工智能&#xff08;AI&#xff09;已经逐渐渗透到各个行业之中&#xff0c;其中客服行业正经历着一场前所未有的变革。AI技术的引入&#xff0c;为客服行业注入了智能化、自动化和数据驱动的新动力&#xff0c;引领着客服行业迈向一个崭新的时…

数据仓库的数据处理架构Lambda和Kappa

1.数据仓库 数据仓库(Data Warehouse),简写DW。顾名思义,数据仓库是一个很大的数据存储集合,为企业分析性报告和决策支持而创建,是对多元业务数据的筛选与整合,具备一定的BI能力,主要用于企业的数据分析、数据挖掘、数据报表等方向,指导业务流程改进、监视时间、成本、…

[Linux开发工具]——make/Makefile的使用

Linux项目自动化构建工具——make/Makefile 前言&#xff1a;一、背景二、认识make和makefile2.1 创建Makefile文件2.2 创建test.c文件&#xff0c;并打开Makefile2.3 我们想要test.c生成test文件2.4 编译2.5 清理可执行文件 三、理解依赖关系和依赖方法3.1 依赖关系3.2 依赖方…

发展的挺快的Rust

C 可能在将来会逐步的退出历史舞台 Rust 在linux 上出现的频次越来越多了 新的语言和重构带来了更方便快捷的体验 好玩的命令集合 https://github.com/ibraheemdev/modern-unix.git 这速度&#xff0c;这花活儿

07、面向对象进阶

面向对象进阶 文章目录 面向对象进阶static关键字继承多态包final抽象类与抽象方法接口拓展 内部类成员内部类静态内部类局部内部类匿名内部类 static关键字 static表示静态&#xff0c;是Java中的一个修饰符&#xff0c;可以修饰成员方法&#xff0c;成员变量 静态变量是随着…

C++ Qt开发:QProcess进程管理模块

Qt 是一个跨平台C图形界面开发库&#xff0c;利用Qt可以快速开发跨平台窗体应用程序&#xff0c;在Qt中我们可以通过拖拽的方式将不同组件放到指定的位置&#xff0c;实现图形化开发极大的方便了开发效率&#xff0c;本章将重点介绍如何运用QProcess组件实现针对进程的控制管理…

mysqly索引(explain 执行计划)

关键词 执行计划 EXPLAIN 语句查看mysql 优化后的语句 show warnings;EXPLAIN 执行后&#xff0c;各列的含义 要点&#xff1a; select_type 如何查询 表type 如何查询 行key 如何使用 索引key_len 索引 使用多少rows 行 预计使用多少extra 表 的额外信息 1.id id列的编…

Spring之@Qualifier注解

场景重现 当我们注入的依赖存在多个候选者,我们得使用一些方法来筛选出唯一候选者,否则就会抛出异常 demo演示 创建接口Car,以及两个实现其接口的bean public interface Car { }Component public class RedCar implements Car { }Component public class WhiteCar implemen…

荒野大嫖客2找不到emp.dll解决办法

首先我参考了几篇文章尝试来解决这个问题&#xff0c; s霍格沃兹emp.dll文件丢失要怎么处理&#xff1f;快速修复emp.dll的方法-CSDN博客 使用电脑自带的修复工具&#xff0c;直接按键盘的winr&#xff0c;然后输入cmd&#xff0c;打开小黑板&#xff0c;我们再在小黑板上输入…

MQTT 简介

MQTT 简介 MQTT 是非常简单的协议&#xff0c;最初由 IBM 的两位工程师 Andy Stanford-Clark 以及 Arlen Nipper 在 1999 年为监控输油管道设计的。它被设计的场景就是有限的带宽、轻量级以及很小的耗电量&#xff0c;在那个时候&#xff0c;卫星宽带就是那么小&#xff0c;且…

【理解机器学习算法】之Clustering算法(Agglomerative Clustering)

聚合聚类(Agglomerative Clustering)是一种层次聚类算法&#xff0c;通过逐步合并或“聚集”它们来构建嵌套聚类。这种方法采用自底向上的方式构建聚类层次&#xff1a;它从将每个数据点作为单个聚类开始&#xff0c;然后迭代合并最接近的聚类对&#xff0c;直到所有数据点合并…

【机器学习】一文搞懂算法模型之:Transformer

Transformer 1、引言2、Transformer2.1 定义2.2 原理2.3 算法公式2.3.1 自注意力机制2.3.1 多头自注意力机制2.3.1 位置编码 2.4 代码示例 3、总结 1、引言 小屌丝&#xff1a;鱼哥&#xff0c; 你说transformer是个啥&#xff1f; 小鱼&#xff1a;嗯… 啊… 嗯…就是… 小屌…

【Java Web基础】一些网页设计基础(四)

文章目录 1. 做Tab切换2. 下面的内容展示——Card样式3. 采供分类&#xff0c;分类用面包屑导航做4. 出名企业展示&#xff0c;就是普通的图片5. 用热门商品类似的panel做一个农博会展览 1. 做Tab切换 使用BootStrap提供的样式&#xff1a; <ul class"nav nav-tabs&q…

【Redis】缓存穿透

问题发生背景&#xff1a;客户端请求的数据再缓存中和数据库中都不存在。 导致的问题&#xff1a;缓存永远不会生效&#xff0c;这些请求都会去请求数据库—导致数据库压力增大。 解决方案&#xff1a; 1.缓存空对象 在Redis中缓存空对象&#xff0c;告诉客户端数据库中没有该值…

uni-app攻略:如何对接驰腾打印机

一.引言 在当前的移动开发生态中&#xff0c;跨平台框架如uni-app因其高效、灵活的特点受到了开发者们的青睐。同时&#xff0c;随着物联网技术的飞速发展&#xff0c;智能打印设备已成为许多业务场景中不可或缺的一环。今天&#xff0c;我们就来探讨如何使用uni-app轻松对接驰…

Codeforces Round 935 (Div. 3)A~E

A. Setting up Camp 题目分析: 有三种人&#xff0c;内向、外向、综合&#xff0c;内向必须独自一个帐篷&#xff0c;外向必须3个人一个帐篷&#xff0c;综合介于1~3人一个帐篷&#xff0c;我们发现非法情况只会存在外向的人凑不成3个人一个帐篷的情况&#xff0c;因外向不够可…

软件管理rpm与yum

源代码包下载 Compare, Download & Develop Open Source & Business Software - SourceForgehttps://sourceforge.net/ rpm包下载 Welcome to the RPM repository on fr2.rpmfind.nethttp://rpmfind.net/linux/RPM/ 软件包管理 1.rpm包管理: 1)查询: 安装…

微隔离有哪些作用

当前&#xff0c;在零信任安全渐渐被大家熟知的情况下&#xff0c;很多用户在网络安全方面有了更深的认知。在网络安全领域&#xff0c;许多企业用户认为零信任对于降低网络安全风险至关重要&#xff0c;有助于在复杂的网络环境中保护自身企业资源免受未经授权的访问和潜在的网…

HDFSRPC安全认证Token篇

本文主要阐述HDFSRPC安全认证相关的实现。主要介绍Token相关的实现。 写在前面 相关blog https://blog.csdn.net/hncscwc/article/details/124722784 https://blog.csdn.net/hncscwc/article/details/124958357 Token由来 在探究完Kerberos&#xff0c;我一直在想一个问题…

python基本概念和基本数据类型

一、基本概念 1.变量 变量是编程语言中最基本的概念&#xff0c;和字面意思一样&#xff0c;指的就是他们的值可变&#xff0c;和我们以前学习的方程类似&#xff0c;变量可以代入任何值。 命名规范&#xff1a;变量一般使用&#xff1a; 英文字母、下划线 和 数字组成 2.关键…