本站提倡有节制游戏,合理安排游戏时间,注意劳逸结合。

【hashmap源码怎么分析】【html飘雪源码】【mpg源码版本】unlink源码分析

2024-12-23 23:37:47 来源:娱乐 分类:娱乐

1.代码审计思路之PHP代码审计
2.将一个指针 free 两次之后会发生什么?
3.简单说说ConcurrentSkipListMap
4.house of storm 的源码利用
5.鸿蒙轻内核M核源码分析:LibC实现之Musl LibC
6.[redis 源码走读] maxmemory 数据淘汰策略

unlink源码分析

代码审计思路之PHP代码审计

       ×0 前言

       进行PHP代码审计时,关注点与目标明确对提升审计效率至关重要。分析本文将分享PHP代码审计的源码一些思路和方法,帮助在审计过程中更加系统地发现潜在问题。分析

       ×1 前期工作,源码需要的工具

       使用集成环境PHPStorm可以提高代码编写与调试的效率。静态代码扫描工具如Fotify有助于快速识别代码中的分析hashmap源码怎么分析问题,降低误报率。源码seay和CodeQl是分析源代码审计与自动化代码审计的强大工具,其中CodeQl为非商业的源码开源选择。Xcheck是分析一款专注于检测业务代码安全风险的工具,特别适用于寻找由不可信输入引发的源码安全漏洞。

       ×3 明确目标

       在进行审计前,分析首先要明确审计的源码目的,可能有三种情况:提升审计经验、分析寻找可利用的源码漏洞、挖掘0day或证书。不同目的下的审计侧重点不同,例如为了发现漏洞进行渗透测试,可以重点使用自动化工具,关注文件上传、包含、SQL注入等严重危害的漏洞。

       一>所有资源获取

       ×4 判断是否是用了框架

       了解是否使用了框架对审计过程至关重要,框架的结构通常更规整,易于定位关键函数集。对于使用了框架的项目,审计重点在于控制器(C)部分,因为大部分功能点都集中在控制器中。

       PHP主流框架包括Laravel、html飘雪源码ThinkPHP、yii等,它们大多采用MVC设计模式。对于ThinkPHP,其目录结构在版本3和5有所不同,但控制器(C)仍是审计的关键。

       4.2. Laravel框架

       在Laravel框架中,审计重点同样集中在控制器(C)中,因为大部分功能实现都在这里。

       4.3. 如果没用框架

       没有使用框架时,需要关注的点包括函数集文件、配置文件、安全过滤文件、index文件等。函数集文件通常包含function或common关键字,配置文件中可能包含config关键字,安全过滤文件对审计至关重要。

       ×5 了解路由

       了解路由有助于快速定位漏洞位置。对于框架如Thinkphp,其路由规则清晰,审计时可通过路由直接访问漏洞方法。不同模式的路由配置(普通模式、混合模式、强制模式)需了解清楚,以便更好地定位和利用。

       ×6 审计

       在审计前,可以使用自动化工具如xcheck、Fotify、mpg源码版本codeql等进行初步扫描。根据报告验证审计发现,然后按类型深入审计,如SQL注入、XSS、CSRF、SSRF、XML外部实体注入等。

       6.1. 鉴权

       对于权限认证的审计,主要关注是否存在越权访问和未授权访问情况,通常后台管理是需要权限认证的地方。

       6.2. 按照漏洞类型审计

       根据漏洞类型定位可能存在漏洞的地方,如SQL注入、XSS、CSRF、SSRF、XML外部实体注入等,然后回溯验证参数可控性,快速定位漏洞。

       6.2.1. SQL注入

       审计时,重点关注是否存在字符串拼接并可被用户控制的SQL语句。

       6.2.2. XSS漏洞

       注意直接输出用户输入的地方,检查数据输出函数和全局拦截器、过滤器。

       6.2.3. CSRF漏洞

       CSRF攻击利用场景通常涉及敏感功能,审计时寻找生成随机token和token验证的逻辑。

       6.2.4. SSRF漏洞

       审计时注意访问端口、协议和内网IP的css 评价 源码限制,以及使用file、tl_exec、popen等关键词,回溯参数可控性。

       6.2.. 任意文件下载/下载漏洞审计

       关注fget、file_get_contents、readfile、parse_ini_file、highlight_file、file、fopen、readfile、fread等函数,验证变量可控性。

       6.2.. 任意文件删除

       审计时搜索rmdir、unlink等函数,确保变量可控。

       6.2.. 任意文件写入

       注意copy、file_put_contents、fwrite等函数,检查可控变量。

       6.2.. 会话认证漏洞

       审计会话认证漏洞时,需关注cookie生成逻辑、用户身份验证方式,确保会话状态安全。

       6.2.. 反序列化漏洞

       审计时注意全局搜索serialize,检查是否存在可控变量。

将一个指针 free 两次之后会发生什么?

       当一个在 C 语言中通过 malloc 动态分配的山寨qq 源码内存,被 free 释放后,再进行第二次释放,这种行为被称为 double free,它在软件中常被视为一种潜在的二进制漏洞。一个具体的例子来自一道过去的 0ctf 竞赛,旨在通过逆向工程来理解其可能带来的风险。程序源代码可以在 github 上找到,环境为ubuntu . x_,使用了ida, pwntools, pwndbg等工具进行分析。

       在逆向后的代码中,注意到关键点是,即使一个指针被 free 一次后,如果未被置空,它仍可能在后续执行中被误用,导致 double free。正确的做法是将空指针设置为 NULL,以保证安全。此外,代码中涉及了一个固定的存储区域,存储着 note0 字符串的地址,通过 double free 改变这个地址,可以影响程序的控制流,比如覆盖 got 表。

       漏洞利用过程包括信息泄漏、chunk 的动态管理(如unlink函数导致的内存合并)以及伪造堆块以实现任意位置的读写。特别是通过覆盖 got 表,可以将 free 函数重定向到 system(),从而造成任意代码执行。

       总的来说,double free 不仅可能导致内存混乱,更可能成为恶意攻击的入口。因此,开发者在编程时务必谨慎处理内存的分配和释放,以防止此类漏洞的发生。

简单说说ConcurrentSkipListMap

       åŸºæœ¬ä»‹ç»

       è·³è·ƒè¡¨çš„性质如下:

       æœ€åº•å±‚的数据节点按照关键字key升序排列;

       åŒ…含多级索引,每个级别的索引节点按照其关联的数据节点的关键字key升序排列;

       é«˜çº§åˆ«ç´¢å¼•æ˜¯å…¶ä½Žçº§åˆ«ç´¢å¼•çš„子集;

       å¦‚果关键字key在级别level=i的索引中出现,则级别level<=i的所有索引都包含该key。

       è·³è·ƒè¡¨ConcurrentSkipListMap的数据结构如下图所示,下图一共有三层索引,最底下为数据节点,同一层索引中,索引节点之间使用right指针相连,上层索引节点的down指针指向下层的索引节点。

源码分析核心字段分析

       head 指向 node(BASE_HEADER) 的顶层索引。

/***Thetopmostheadindexoftheskiplist.*/privatetransientvolatileHeadIndex<K,V>head;

       BASE_HEADER 头结点,即最顶层索引的头节点的value值

/***Specialvalueusedtoidentifybase-levelheader*/privatestaticfinalObjectBASE_HEADER=newObject()

       Node 静态内部类,即数据节点

/***数据节点*/staticfinalclassNode<K,V>{ finalKkey;//数据节点的keyvolatileObjectvalue;//数据节点的valuevolatileNode<K,V>next;//指向下一个数据节点/***Createsanewregularnode.*/Node(Kkey,Objectvalue,Node<K,V>next){ this.key=key;this.value=value;this.next=next;}}

       Index 静态内部类,即普通索引节点

/***普通索引节点*/staticclassIndex<K,V>{ finalNode<K,V>node;//索引节点指向的数据节点finalIndex<K,V>down;//当前索引节点的正下方索引节点volatileIndex<K,V>right;//当前索引节点的右索引节点/***Createsindexnodewithgivenvalues.*/Index(Node<K,V>node,Index<K,V>down,Index<K,V>right){ this.node=node;this.down=down;this.right=right;}}

       HeadIndex 静态内部类,即当前级别索引的头节点

/***当前级别索引的头节点*/staticfinalclassHeadIndex<K,V>extendsIndex<K,V>{ finalintlevel;//所处索引级别/***node:当前索引指向的数据节点*down:当前索引节点的正下方索引节点*right:当前索引节点的右索引节点*level:当前索引头节点所处的索引级别*/HeadIndex(Node<K,V>node,Index<K,V>down,Index<K,V>right,intlevel){ super(node,down,right);this.level=level;}}查询

       æ ¹æ®æŒ‡å®šçš„key查询节点,源码如下:

publicVget(Objectkey){ //调用doGet方法returndoGet(key);}/***真正实现查询方法*/privateVdoGet(Objectkey){ if(key==null)thrownewNullPointerException();Comparator<?superK>cmp=comparator;outer:for(;;){ for(Node<K,V>b=findPredecessor(key,cmp),n=b.next;;){ Objectv;intc;if(n==null)breakouter;Node<K,V>f=n.next;if(n!=b.next)//inconsistentreadbreak;if((v=n.value)==null){ //nisdeletedn.helpDelete(b,f);break;}if(b.value==null||v==n)//bisdeletedbreak;if((c=cpr(cmp,key,n.key))==0){ @SuppressWarnings("unchecked")Vvv=(V)v;returnvv;}if(c<0)breakouter;b=n;n=f;}}returnnull;}

       åœ¨ä¸Šè¿°ä»£ç ä¸­ï¼Œouter处的for自旋中,首先查看findPredecessor:查询指定key节点的前驱节点。该方法在下面的好多地方会调用,例如插入元素,删除元素以及删除元素对应的索引时都会调用。

       findPredecessor方法源码如下:

/***作用1:找到key对应节点的前驱节点,不一定的真的前驱节点,也可能是前驱结点的前驱节点*作用2:删除无效的索引,即要删除节点时,将节点的索引也删除掉*/privateNode<K,V>findPredecessor(Objectkey,Comparator<?superK>cmp){ if(key==null)thrownewNullPointerException();//don'tpostponeerrorsfor(;;){ //r为q节点的右指针指向的节点,r为当前比较节点,每次都比较r节点的key跟查找的key的大小关系for(Index<K,V>q=head,r=q.right,d;;){ if(r!=null){ Node<K,V>n=r.node;Kk=n.key;//该节点已经删除,需要删除其对应的索引if(n.value==null){ //该节点已经删除,需要删除其对应的索引if(!q.unlink(r))break;//restartr=q.right;//rereadrcontinue;}//当前查找的key比r节点的key大,所以r、q节点都向右移动if(cpr(cmp,key,k)>0){ q=r;r=r.right;continue;}}//当q的下方索引节点为空,则说明已经到数据节点层了,需要退出进行后续查找处理if((d=q.down)==null)returnq.node;/***此时当前查找的key小于r节点的key,需要往下一级索引查找*d节点赋值为为q节点为正下方节点,即下一级索引的正下方节点*/q=d;r=d.right;}}}

       findPredecessor方法的查找过程图示如下:假设要查找节点6

       ç”±äºŽå½“前r节点的key比查询的key小,所以,r、q节点都向右移动,即执行如下代码:

//当前查找的key比r节点的key大,所以r、q节点都向右移动if(cpr(cmp,key,k)>0){ q=r;r=r.right;continue;}

       æ­¤æ—¶r节点指向的数据节点为,节点的key比6节点的key大,此时需要执行如下代码:

/***此时当前查找的key小于r节点的key,需要往下一级索引查找*d节点赋值为为q节点为正下方节点,即下一级索引的正下方节点*/q=d;r=d.right;

       æ­¤æ—¶r节点指向的数据节点为5,5节点的key比6节点的key小,q、r节点向右移动,如下图所示

       æ­¤æ—¶r节点指向的数据节点为,节点的key比6节点的key大,同理需要往下级索引走,如下图所示:

       æ­¤æ—¶r节点指向的数据节点为,节点的key比6节点的key大,同理需要往下级索引走,但是此时下一级索引为空了,即(d = q.down) == null了,此时执行的代码如下, 返回q索引指向的节点,即返回节点5.

//当q的下方索引节点为空,则说明已经到数据节点层了,需要退出进行后续查找处理if((d=q.down)==null)returnq.node;

       ä»¥ä¸Šå°±æ˜¯æ–¹æ³•findPredecessor的查找流程,咱们接着继续看上面的doGet方法

/***Specialvalueusedtoidentifybase-levelheader*/privatestaticfinalObjectBASE_HEADER=newObject()0

       é¦–先初始化b、n、f三个节点,如下图所示

        发现此时n节点指向的节点就是要查询的节点,于是执行如下代码:

/***Specialvalueusedtoidentifybase-levelheader*/privatestaticfinalObjectBASE_HEADER=newObject()1

       ç›´æŽ¥è¿”回n节点的value值。查询操作完成。

插入

       è·³è·ƒè¡¨çš„插入操作分以下四种情况:

       æƒ…况1:跳跃表内存在key一致元素,做替换

       æƒ…况2:插入新元素,无须给新元素生成索引节点

       æƒ…况3:插入新元素,需要给新元素生成索引节点,且索引高度 < maxLevel

       æƒ…况4:插入新元素,需要给新元素生成索引节点,且索引高度 > maxLevel

       æºç å¦‚下:

/***Specialvalueusedtoidentifybase-levelheader*/privatestaticfinalObjectBASE_HEADER=newObject()2

       é¦–先还是跟查询操作类似,调用findPredecessor方法先查找到待插入key的前驱节点,举个例子,例如我们想要插入节点7,如下图所示:

       æŽ¥ç€è·ŸæŸ¥è¯¢æ“ä½œä¸€æ ·çš„步骤如下,直接看图:

        此时r节点指向数据节点1,节点1的key小于待插入的节点7的key,于是节点q、r同时向右移动。

       æ­¤æ—¶r节点指向数据节点,节点的key大于待插入节点7的key,于是往下一层索引继续查找,执行的代码如下:

/***Specialvalueusedtoidentifybase-levelheader*/privatestaticfinalObjectBASE_HEADER=newObject()3

       åŽé¢çš„操作类似

       æ­¤æ—¶r节点的key大于待插入的节点6的key,但是q节点的down指针已为空,此时直接返回q节点指向的节点5。

       æŽ¥ç€å›žåˆ°doPut方法,先来查看outer循环,如下:

/***Specialvalueusedtoidentifybase-levelheader*/privatestaticfinalObjectBASE_HEADER=newObject()4

       é¦–先初始化三个节点b、n、f,n节点为b节点的下一个节点,而f节点为n节点的下一个节点,如下图所示

       æŽ¥ç€æ¯”较节点n与待插入的key的大小,此时n节点的key小于待插入节点的key,于是b、n、f三个节点均向下移动如下图所示

       æ­¤æ—¶n节点的key大于待插入的key,此时执行如下代码,通过cas方式修改b节点的下一个节点为z节点,接着跳出outer循环。

/***Specialvalueusedtoidentifybase-levelheader*/privatestaticfinalObjectBASE_HEADER=newObject()5

       ç„¶åŽæˆ‘们知道doPut剩下的代码无非就是判断是否给新插入的节点z创建索引,如果需要创建对应的索引。

       é¦–先通过int rnd = ThreadLocalRandom.nextSecondarySeed();计算出一个随机数,接着进行如下判断:

/***Specialvalueusedtoidentifybase-levelheader*/privatestaticfinalObjectBASE_HEADER=newObject()6

       å¦‚æžœrnd & 0x) == 0就给新插入的z节点创建索引,我们知道0x = 即最高位和最后一位为1,其余全部是0,

       æ¡ä»¶ï¼š(rnd & 0x) == 0什么时候成立?

       rnd这个随机数最低位和最高位同时是0的时候,条件成立,概率是1/4

       ä¸¾ä¸ªä¾‹å­ï¼šä¾‹å¦‚rnd = = 3条件就成立。

       å¦‚果条件成立的话,接着计算到底给z节点创建几级索引,代码如下:

/***Specialvalueusedtoidentifybase-levelheader*/privatestaticfinalObjectBASE_HEADER=newObject()7

       é€šè¿‡while条件((rnd >>>= 1) & 1) != 0满足几次就创建几级索引。例如:

       rnd = 计算出来的level => 3

       rnd = 计算出来的level => 8

       ç„¶åŽæŽ¥ç€æ¯”较计算出来的z节点的索引跟现有的跳跃表的索引级别大小。

       æƒ…况一:z节点计算出来的索引level比跳跃表的level小

       æƒ…况二:z节点计算处理的索引level比跳跃表的level大。此时会选择最终的level为原来的调表的level + 1

       æƒ…况一

       ç»™z节点创建索引的步骤如下图所示,此时z节点的索引还没有加入跳跃表现有的索引队列中

       æŽ¥ç€ç»§ç»­æ‰§è¡Œsplice循环,代码如下:

/***Specialvalueusedtoidentifybase-levelheader*/privatestaticfinalObjectBASE_HEADER=newObject()8

       åˆå§‹åŒ–q、r节点如下图所示

       æ­¤æ—¶r节点的key比新插入z节点,即7节点小,于是两个节点q、t都向右移动如下图所示

       æ­¤æ—¶r节点的key比新插入z节点,即7节点大,执行如下代码:

/***Specialvalueusedtoidentifybase-levelheader*/privatestaticfinalObjectBASE_HEADER=newObject()9

       æ­¤æ—¶r节点的key比新插入z节点,即7节点小,于是两个节点q、t都向右移动如下图所示

       æ­¤æ—¶r节点的key比新插入z节点,即7节点大,同理,直接看图

       æƒ…况二

       è·Ÿæƒ…况一类似,这里就不一一画图了

删除

       åˆ é™¤æ–¹æ³•å®Œæˆçš„任务如下:

       è®¾ç½®æŒ‡å®šå…ƒç´ value为null

       å°†æŒ‡å®šnode从node链表移除

       å°†æŒ‡å®šnode的index节点 从 对应的 index 链表移除

/***数据节点*/staticfinalclassNode<K,V>{ finalKkey;//数据节点的keyvolatileObjectvalue;//数据节点的valuevolatileNode<K,V>next;//指向下一个数据节点/***Createsanewregularnode.*/Node(Kkey,Objectvalue,Node<K,V>next){ this.key=key;this.value=value;this.next=next;}}0

       åŒæ ·ï¼Œé¦–先通过findPredecessor方法查找到要删除key的前驱节点,就不一一画图了,直接看找到的前驱节点的图,如下:

       æŽ¥æ¯”较n节点的key与待删除的key的大小,此时n节点的key小于待删除的key,即7节点的key,于是将b、n、f三个节点都向右移动,如下图:

       æ­¤æ—¶n节点的key跟待删除的key一样,于是执行如下代码:

/***数据节点*/staticfinalclassNode<K,V>{ finalKkey;//数据节点的keyvolatileObjectvalue;//数据节点的valuevolatileNode<K,V>next;//指向下一个数据节点/***Createsanewregularnode.*/Node(Kkey,Objectvalue,Node<K,V>next){ this.key=key;this.value=value;this.next=next;}}1

       æœ€åŽå†è°ƒç”¨findPredecessor清楚无效的索引,即上面删除的节点的索引。

/***数据节点*/staticfinalclassNode<K,V>{ finalKkey;//数据节点的keyvolatileObjectvalue;//数据节点的valuevolatileNode<K,V>next;//指向下一个数据节点/***Createsanewregularnode.*/Node(Kkey,Objectvalue,Node<K,V>next){ this.key=key;this.value=value;this.next=next;}}2

       é‡ç‚¹é å¦‚下代码块删除索引的:

/***数据节点*/staticfinalclassNode<K,V>{ finalKkey;//数据节点的keyvolatileObjectvalue;//数据节点的valuevolatileNode<K,V>next;//指向下一个数据节点/***Createsanewregularnode.*/Node(Kkey,Objectvalue,Node<K,V>next){ this.key=key;this.value=value;this.next=next;}}3

       æˆ‘们知道在上面已经将待删除的7节点的value置为null了,直接看图:

       æ­¤æ—¶r节点的key小于待删除节点的key,于是r、q节点都向右移动。

       æ­¤æ—¶r,n节点指向的数据节点的value值为null于是执行上面的q.unlink(r)代码,将q的右指针指向r的右指针指向的节点,即就是删除了该level上的7节点的索引节点,如下图所示

       æ­¤æ—¶r节点的key大于待删除节点的key,于是往下一索引走,如下图所示

       æ­¤æ—¶r节点的key小于待删除节点的key,于是r、q节点都向右移动。

       æ­¤æ—¶r,n节点指向的数据节点的value值为null于是执行上面的q.unlink(r)代码,将q的右指针指向r的右指针指向的节点,即就是删除了该level上的7节点的索引节点,如下图所示

       åŽç»­æ“ä½œåŒç†ï¼Œæœ€ç»ˆå°†7节点的索引一一删除完,最终的图下所示

house of storm 的利用

       作者:hope 合天智汇

       利用 mallopt 和 mmap 构建 House of Storm

       首先,通过 mallopt 函数关闭 fastbin 功能,然后利用 mmap 动态分配一块地址空间,范围在 0x-0x。通过 open("/dev/urandom",0) 获取随机数,然后在地址 0x 开始写入 个字节,填充异或后的随机数。

       接下来的 for 循环中,不断将 mmap 地址空间填充异或后的随机数,操作的输入 size 限定在 0xc 到 0x 之间。写入后的堆块地址和 size 会通过异或操作存储到同一地址段。

       show 函数的限制

       初始状态下,由于 show 函数的条件,程序无法直接输入信息,需要进行相应的修改才能输出结果。

       edit 功能中的漏洞

       edit 功能允许输入的 size 值必须是通过 add 时指定的 size 减去 0xc,因为这 0xc 的空间会被自动填充数据,但意外地多填充了 0 字节,导致 off-by-null 漏洞。这种漏洞被利用来实现 chunk shrink。

       利用 off-by-null 漏洞实现 chunk shrink

       编辑部分解释了 off-by-null 漏洞是如何影响 size 域,以及为何需要构造特定的堆块大小以绕过 unlink 检测。

       编辑后的堆块构造旨在构造两个 largebin 大小的堆块,通过 off-by-null 改变堆块的大小并触发 unlink 操作,实现堆块的堆叠。

       利用 unsortbin 和 largebin 的攻击

       攻击策略包括伪造 unsortbin 中的堆块,以实现任意地址的堆块分配。通过调整bk指针和 size 值,能够控制链表遍历过程,获取目标堆块。

       总结与实践

       这道题目展示了如何利用 House of Storm 技术,涉及的知识点包括 unsortbin 的操作、unlink 检测规避以及堆块重叠等。在学习过程中,建议深入阅读源码,并对相关概念进行归纳和总结。

       最后,作者希望读者在实践中保持警惕,确保网络安全,所有行为后果自负。

鸿蒙轻内核M核源码分析:LibC实现之Musl LibC

       本文探讨了LiteOS-M内核中Musl LibC的实现,重点关注文件系统与内存管理功能。Musl LibC在内核中提供了两种LibC实现选项,使用者可根据需求选择musl libC或newlibc。本文以musl libC为例,深度解析其文件系统与内存分配释放机制。

       在使用musl libC并启用POSIX FS API时,开发者可使用文件kal\libc\musl\fs.c中定义的文件系统操作接口。这些接口遵循标准的POSIX规范,具体用法可参阅相关文档,或通过网络资源查询。例如,mount()函数用于挂载文件系统,而umount()和umount2()用于卸载文件系统,后者还支持额外的卸载选项。open()、close()、unlink()等文件操作接口允许用户打开、关闭和删除文件,其中open()还支持多种文件创建和状态标签。read()与write()用于文件数据的读写操作,lseek()则用于文件读写位置的调整。

       在内存管理方面,LiteOS-M内核提供了标准的POSIX内存分配接口,包括malloc()、free()与memalign()等。其中,malloc()和free()用于内存的申请与释放,而memalign()则允许用户以指定的内存对齐大小进行内存申请。

       此外,calloc()函数在分配内存时预先设置内存区域的值为零,而realloc()则用于调整已分配内存的大小。这些函数构成了内核中内存管理的核心机制,确保资源的高效利用与安全释放。

       总结而言,musl libC在LiteOS-M内核中的实现,通过提供全面且高效的文件系统与内存管理功能,为开发者提供了强大的工具集,以满足不同应用场景的需求。本文虽已详述关键功能,但难免有所疏漏,欢迎读者在遇到问题或有改进建议时提出,共同推动技术进步。感谢阅读。

[redis 源码走读] maxmemory 数据淘汰策略

       Redis 是一个内存数据库,通过配置 `maxmemory` 来限定其内存使用量。当 Redis 主库内存超出限制时,会触发数据淘汰机制,以减少内存使用量,直至达到限制阈值。

       当 `maxmemory` 配置被应用,Redis 会根据配置采用相应的数据淘汰策略。`volatile-xxx` 类型配置仅淘汰设置了过期时间的数据,而 `allkeys-xxx` 则淘汰数据库中所有数据。若 Redis 主要作为缓存使用,可选择 `allkeys-xxx`。

       数据淘汰时机发生在事件循环处理命令时。有多种淘汰策略可供选择,从简单到复杂包括:不淘汰数据(`noeviction`)、随机淘汰(`volatile-random`、`allkeys-random`)、采样淘汰(`allkeys-lru`、`volatile-lru`、`volatile-ttl`、`volatile-freq`)以及近似 LRU 和 LRU 策略(`volatile-lru` 和 `allkeys-lru`)。

       `noeviction` 策略允许读操作但禁止大多数写命令,返回 `oomerr` 错误,仅允许执行少量写命令,如删除命令 `del`、`hdel` 和 `unlink`。

       `volatile-random` 和 `allkeys-random` 机制相对直接,随机淘汰数据,策略相对暴力。

       `allkeys-lru` 策略根据最近最少使用(LRU)算法淘汰数据,优先淘汰最久未使用的数据。

       `volatile-lru` 结合了过期时间与 LRU 算法,优先淘汰那些最久未访问且即将过期的数据。

       `volatile-ttl` 策略淘汰即将过期的数据,而 `volatile-freq` 则根据访问频率(LFU)淘汰数据,考虑数据的使用热度。

       `volatile-lru` 和 `allkeys-lru` 策略通过采样来近似 LRU 算法,维护一个样本池来确定淘汰顺序,以提高淘汰策略的精确性。

       总结而言,Redis 的数据淘汰策略旨在平衡内存使用与数据访问需求,通过灵活的配置实现高效的数据管理。策略的选择应基于具体应用场景的需求,如数据访问模式、性能目标等。

相关推荐
一周热点