Redis的缓存策略和主键失效机制

本文涉及的产品
云数据库 Redis 版,社区版 2GB
推荐场景:
搭建游戏排行榜
简介:

作为缓存系统都要定期清理无效数据,就需要一个主键失效和淘汰策略。

>>EXPIRE主键失效机制

在Redis当中,有生存期的key被称为volatile,
在创建缓存时,要为给定的key设置生存期,当key过期的时候(生存期为0),它可能会被删除。

(1)影响生存时间的一些操作

生存时间可以通过使用 DEL 命令来删除整个 key 来移除,或者被 SET 和 GETSET 命令覆盖原来的数据,

也就是说,修改key对应的value和使用另外相同的key和value来覆盖以后,当前数据的生存时间不同。

比如说,对一个 key 执行INCR命令,对一个列表进行LPUSH命令,或者对一个哈希表执行HSET命令,这类操作都不会修改 key 本身的生存时间。

另一方面,如果使用RENAME对一个 key 进行改名,那么改名后的 key 的生存时间和改名前一样。

RENAME命令的另一种可能是,尝试将一个带生存时间的 key 改名成另一个带生存时间的 another_key ,这时旧的 another_key (以及它的生存时间)会被删除,然后旧的 key 会改名为 another_key ,因此,新的 another_key 的生存时间也和原本的 key 一样。
使用PERSIST命令可以在不删除 key 的情况下,移除 key 的生存时间,让 key 重新成为一个persistent key 。

(2)如何更新生存时间

可以对一个已经带有生存时间的 key 执行EXPIRE命令,新指定的生存时间会取代旧的生存时间。
过期时间的精度已经被控制在1ms之内,主键失效的时间复杂度是O(1),
EXPIRE和TTL命令搭配使用,TTL可以查看key的当前生存时间
设置成功返回 1;当 key 不存在或者不能为 key 设置生存时间时,返回 0 。

>>最大缓存配置

在 redis 中,允许用户设置最大使用内存大小

1
server.maxmemory

默认为0,没有指定最大缓存,如果有新的数据添加,超过最大内存,则会使redis崩溃,所以一定要设置。
redis 内存数据集大小上升到一定大小的时候,就会实行数据淘汰策略。

redis 提供 6种数据淘汰策略:

volatile-lru:从已设置过期时间的数据集(server.db[i].expires)中挑选最近最少使用的数据淘汰
volatile-ttl:从已设置过期时间的数据集(server.db[i].expires)中挑选将要过期的数据淘汰
volatile-random:从已设置过期时间的数据集(server.db[i].expires)中任意选择数据淘汰
allkeys-lru:从数据集(server.db[i].dict)中挑选最近最少使用的数据淘汰
allkeys-random:从数据集(server.db[i].dict)中任意选择数据淘汰
no-enviction(驱逐):禁止驱逐数据

注意这里的6种机制,volatile和allkeys规定了是对已设置过期时间的数据集淘汰数据还是从全部数据集淘汰数据,
后面的lru、ttl以及random是三种不同的淘汰策略,再加上一种no-enviction永不回收的策略。

使用策略规则:

(1)如果数据呈现幂律分布,也就是一部分数据访问频率高,一部分数据访问频率低,则使用allkeys-lru。
(2)如果数据呈现平等分布,也就是所有的数据访问频率都相同,则使用allkeys-random。

三种数据淘汰策略:

ttl和random比较容易理解,实现也会比较简单。主要是Lru最近最少使用淘汰策略,设计上会对key 按失效时间排序,然后取最先失效的key进行淘汰。

>>失效的内部实现

Redis 删除失效主键的方法主要有两种:

消极方法(passive way),在主键被访问时如果发现它已经失效,那么就删除它
积极方法(active way),周期性地从设置了失效时间的主键中选择一部分失效的主键删除
主键具体的失效时间全部都维护在expires这个字典表中。

1
2
3
4
5
6
7
8
typedef struct redisDb {
     dict *dict;  //key-value
     dict *expires;   //维护过期key
     dict *blocking_keys;
     dict *ready_keys;
     dict *watched_keys;
     int  id;
} redisDb;

 

(1)passive way 消极方法

在passive way 中, redis在实现GET、MGET、HGET、LRANGE等所有涉及到读取数据的命令时都会调用 expireIfNeeded,它存在的意义就是在读取数据之前先检查一下它有没有失效,如果失效了就删除它。
expireIfNeeded函数中调用的另外一个函数propagateExpire,这个函数用来在正式删除失效主键之前广播这个主键已经失效的信息,这个信息会传播到两个目的地:
一个是发送到AOF文件,将删除失效主键的这一操作以DEL Key的标准命令格式记录下来;
另一个就是发送到当前Redis服务器的所有Slave,同样将删除失效主键的这一操作以DEL Key的标准命令格式告知这些Slave删除各自的失效主键。从中我们可以知道,所有作为Slave来运行的Redis服务器并不需要通过消极方法来删除失效主键,它们只需要执行Master的删除指令即可。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
int  expireIfNeeded(redisDb *db, robj *key) {
    // 获取主键的失效时间
     long  long  when = getExpire(db,key);
     //假如失效时间为负数,说明该主键未设置失效时间(失效时间默认为-1),直接返回0
     if  (when < 0)  return  0;
    // 假如Redis服务器正在从RDB文件中加载数据,暂时不进行失效主键的删除,直接返回0
     if  (server.loading)  return  0;
    // 假如当前的Redis服务器是作为Slave运行的,那么不进行失效主键的删除,因为Slave
   //  上失效主键的删除是由Master来控制的,但是这里会将主键的失效时间与当前时间进行
    // 一下对比,以告知调用者指定的主键是否已经失效了
     if  (server.masterhost != NULL) {
         return  mstime() > when;
     }
     //如果以上条件都不满足,就将主键的失效时间与当前时间进行对比,如果发现指定的主键
    // 还未失效就直接返回0
     if  (mstime() <= when)  return  0;
    // 如果发现主键确实已经失效了,那么首先更新关于失效主键的统计个数,然后将该主键失
    // 效的信息进行广播,最后将该主键从数据库中删除
     server.stat_expiredkeys++;
     propagateExpire(db,key);
     return  dbDelete(db,key);
}
 
void  propagateExpire(redisDb *db, robj *key) {
     robj *argv[2];
    // shared.del是在Redis服务器启动之初就已经初始化好的一个常用Redis对象,即DEL命令
     argv[0] = shared.del;
     argv[1] = key;
     incrRefCount(argv[0]);
     incrRefCount(argv[1]);
   //  检查Redis服务器是否开启了AOF,如果开启了就为失效主键记录一条DEL日志
     if  (server.aof_state != REDIS_AOF_OFF)
         feedAppendOnlyFile(server.delCommand,db->id,argv,2);
     //检查Redis服务器是否拥有Slave,如果是就向所有Slave发送DEL失效主键的命令,这就是
    // 上面expireIfNeeded函数中发现自己是Slave时无需主动删除失效主键的原因了,因为它
   //  只需听从Master发送过来的命令就OK了
     if  (listLength(server.slaves))
         replicationFeedSlaves(server.slaves,db->id,argv,2);
     decrRefCount(argv[0]);
     decrRefCount(argv[1]);
}

 

(2)Active Way 积极方法

消极方法的缺点是,如果key 迟迟不被访问,就会占用很多内存空间,所以就出现了积极的方式(Active Way),

此方法利用了redis的时间事件,即每隔一段时间就中断一下完成一些指定操作,其中就包括检查并删除失效主键。

A.时间事件

创建时间事件, 回调函数就是serverCron,它在Redis服务器启动时创建,每秒的执行次数由宏定义REDIS_DEFAULT_HZ来指定,默认每秒钟执行10次。

1
2
3
4
5
//该代码在redis.c文件的initServer函数中。实际上,serverCron这个回调函数不仅要进行失效主键的检查与删除,还要进行统计信息的更新、客户端连接超时的控制、BGSAVE和AOF的触发等等,这里我们仅关注删除失效主键的实现,也就是函数activeExpireCycle。
if (aeCreateTimeEvent(server.el, 1, serverCron, NULL, NULL) == AE_ERR) {
         redisPanic( "create time event failed" );
         exit (1);
}

B.使用activeExpireCycle 清除失效key

其实现原理是从Redis中每个数据库的expires字典表中,随机抽样REDIS_EXPIRELOOKUPS_PER_CRON(默认值为10)个设置了失效时间的主键,检查它们是否已经失效并删除掉失效的主键,如果失效主键个数占本次抽样个数的比例超过25%,它会继续进行下一轮的随机抽样和删除,直到刚才的比例低于25%才停止对当前数据库的处理,转向下一个数据库。

注意,activeExpireCycle函数不会试图一次性处理Redis中的所有数据库,而是最多只处理REDIS_DBCRON_DBS_PER_CALL(默认值为16),此外activeExpireCycle函数还有处理时间上的限制,不是想执行多久就执行多久,凡此种种都只有一个目的,那就是避免失效主键删除占用过多的CPU资源。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
void  activeExpireCycle( void ) {
     /*因为每次调用activeExpireCycle函数不会一次性检查所有Redis数据库,所以需要记录下
         每次函数调用处理的最后一个Redis数据库的编号,这样下次调用activeExpireCycle函数
         还可以从这个数据库开始继续处理,这就是current_db被声明为static的原因,而另外一
         个变量timelimit_exit是为了记录上一次调用activeExpireCycle函数的执行时间是否达
         到时间限制了,所以也需要声明为static
     */
     static  unsigned  int  current_db = 0;
     static  int  timelimit_exit = 0;
     unsigned  int  j, iteration = 0;
 
     /**
         每次调用activeExpireCycle函数处理的Redis数据库个数为REDIS_DBCRON_DBS_PER_CALL
         unsigned int dbs_per_call = REDIS_DBCRON_DBS_PER_CALL;
         long long start = ustime(), timelimit;
         如果当前Redis服务器中的数据库个数小于REDIS_DBCRON_DBS_PER_CALL,则处理全部数据库,
         如果上一次调用activeExpireCycle函数的执行时间达到了时间限制,说明失效主键较多,也
         会选择处理全部数据库
     */
     if  (dbs_per_call > server.dbnum || timelimit_exit)
         dbs_per_call = server.dbnum;
 
     /*
         执行activeExpireCycle函数的最长时间(以微秒计),其中REDIS_EXPIRELOOKUPS_TIME_PERC
         是单位时间内能够分配给activeExpireCycle函数执行的CPU时间比例,默认值为25,server.hz
         即为一秒内activeExpireCycle的调用次数,所以这个计算公式更明白的写法应该是这样的,即
             (1000000 * (REDIS_EXPIRELOOKUPS_TIME_PERC / 100)) / server.hz
     */
     timelimit = 1000000*REDIS_EXPIRELOOKUPS_TIME_PERC/server.hz/100;
     timelimit_exit = 0;
     if  (timelimit <= 0) timelimit = 1;
 
     //遍历处理每个Redis数据库中的失效数据
     for  (j = 0; j < dbs_per_call; j++) {
         int  expired;
         redisDb *db = server.db+(current_db % server.dbnum);
       // 此处立刻就将current_db加一,这样可以保证即使这次无法在时间限制内删除完所有当前
       // 数据库中的失效主键,下一次调用activeExpireCycle一样会从下一个数据库开始处理,
        //从而保证每个数据库都有被处理的机会
         current_db++;
        // 开始处理当前数据库中的失效主键
         do  {
             unsigned  long  num, slots;
             long  long  now;
            // 如果expires字典表大小为0,说明该数据库中没有设置失效时间的主键,直接检查下
           // 一数据库
             if  ((num = dictSize(db->expires)) == 0)  break ;
             slots = dictSlots(db->expires);
             now = mstime();
           //  如果expires字典表不为空,但是其填充率不足1%,那么随机选择主键进行检查的代价
            //会很高,所以这里直接检查下一数据库
             if  (num && slots > DICT_HT_INITIAL_SIZE &&
                 (num*100/slots < 1))  break ;
             expired = 0;
             //如果expires字典表中的entry个数不足以达到抽样个数,则选择全部key作为抽样样本
             if  (num > REDIS_EXPIRELOOKUPS_PER_CRON)
                 num = REDIS_EXPIRELOOKUPS_PER_CRON;
             while  (num--) {
                 dictEntry *de;
                 long  long  t;
               //  随机获取一个设置了失效时间的主键,检查其是否已经失效
                 if  ((de = dictGetRandomKey(db->expires)) == NULL)  break ;
                 t = dictGetSignedIntegerVal(de);
                 if  (now > t) {
            // 发现该主键确实已经失效,删除该主键
                     sds key = dictGetKey(de);
                     robj *keyobj = createStringObject(key,sdslen(key));
                     //同样要在删除前广播该主键的失效信息
                     propagateExpire(db,keyobj);
                     dbDelete(db,keyobj);
                     decrRefCount(keyobj);
                     expired++;
                     server.stat_expiredkeys++;
                 }
             }
            // 每进行一次抽样删除后对iteration加一,每16次抽样删除后检查本次执行时间是否
           // 已经达到时间限制,如果已达到时间限制,则记录本次执行达到时间限制并退出
             iteration++;
             if  ((iteration & 0xf) == 0 &&
                 (ustime()-start) > timelimit)
             {
                 timelimit_exit = 1;
                 return ;
             }
         //如果失效的主键数占抽样数的百分比大于25%,则继续抽样删除过程
         while  (expired > REDIS_EXPIRELOOKUPS_PER_CRON/4);
     }
}

  

>>Redis 的主键失效机制对系统性能的影响

Redis 会定期地检查设置了失效时间的主键并删除已经失效的主键,但是通过对每次处理数据库个数的限制、activeExpireCycle 函数在一秒钟内执行次数的限制、分配给 activeExpireCycle 函数CPU时间的限制、继续删除主键的失效主键数百分比的限制,Redis 已经大大降低了主键失效机制对系统整体性能的影响,但是如果在实际应用中出现大量主键在短时间内同时失效的情况还是会产生很多问题,
也就是缓存穿透的情况。

>>如何避免大量主键在同一时间同时失效造成数据库压力过大

合理的配置缓存可以增加系统的健壮性,避免缓存失效造成的事故。
1.在缓存失效后,通过加锁或者队列来控制读数据库写缓存的线程数量。比如对某个key只允许一个线程查询数据和写缓存,其他线程等待。
2.可以通过缓存reload机制,预先去更新缓存.
2.不同的key,设置不同的过期时间,让缓存失效的时间点尽量均匀。
3.做二级缓存,或者双缓存策略。A1为原始缓存,A2为拷贝缓存,A1失效时,可以访问A2,A1缓存失效时间设置为短期,A2设置为长期。

>>Memcached删除失效主键的方法与Redis有何异同?

Memcached 在删除失效主键时采用的消极方法,即 Memcached 内部不会监视主键是否失效,而是在通过 Get 访问主键时才会检查其是否已经失效。
其次,Memcached 与 Redis 在主键失效机制上的最大不同是,Memcached 不会像 Redis 那样真正地去删除失效的主键,而只是简单地将失效主键占用的空间回收。

这样当有新的数据写入到系统中时,Memcached 会优先使用那些失效主键的空间。
如果失效主键的空间用光了,Memcached 还可以通过 LRU 机制来回收那些长期得不到访问的空间,因此 Memcached 并不需要像 Redis 中那样的周期性删除操作,这也是由 Memcached 使用的内存管理机制决定的。
同时, Redis 在出现 OOM时同样可以通过配置 maxmemory-policy 这个参数来决定是否采用 LRU 机制来回收内存空间。


相关实践学习
基于Redis实现在线游戏积分排行榜
本场景将介绍如何基于Redis数据库实现在线游戏中的游戏玩家积分排行榜功能。
云数据库 Redis 版使用教程
云数据库Redis版是兼容Redis协议标准的、提供持久化的内存数据库服务,基于高可靠双机热备架构及可无缝扩展的集群架构,满足高读写性能场景及容量需弹性变配的业务需求。 产品详情:https://www.aliyun.com/product/kvstore &nbsp; &nbsp; ------------------------------------------------------------------------- 阿里云数据库体验:数据库上云实战 开发者云会免费提供一台带自建MySQL的源数据库&nbsp;ECS 实例和一台目标数据库&nbsp;RDS实例。跟着指引,您可以一步步实现将ECS自建数据库迁移到目标数据库RDS。 点击下方链接,领取免费ECS&amp;RDS资源,30分钟完成数据库上云实战!https://developer.aliyun.com/adc/scenario/51eefbd1894e42f6bb9acacadd3f9121?spm=a2c6h.13788135.J_3257954370.9.4ba85f24utseFl
目录
相关文章
|
7天前
|
存储 缓存 NoSQL
Redis缓存的运用
缓存预热就是系统上线后,将相关的缓存数据直接加载到缓存系统。这样就可以避免在用户请 求的时候,先查询数据库,然后再将数据缓存的问题!用户直接查询事先被预热的缓存数据!
11 1
|
2天前
|
缓存 索引
cpu缓存一致性问题---cache写策略
cpu缓存一致性问题---cache写策略
5 1
|
2天前
|
缓存 调度
Eureka的注册表拉取及多级缓存机制简析
Eureka的注册表拉取及多级缓存机制简析
13 2
|
3天前
|
缓存 NoSQL Java
在 SSM 架构(Spring + SpringMVC + MyBatis)中,可以通过 Spring 的注解式缓存来实现 Redis 缓存功能
【6月更文挑战第18天】在SSM(Spring+SpringMVC+MyBatis)中集成Redis缓存,涉及以下步骤:添加Spring Boot的`spring-boot-starter-data-redis`依赖;配置Redis连接池(如JedisPoolConfig)和连接工厂;在Service层使用`@Cacheable`注解标记缓存方法,指定缓存名和键生成策略;最后,在主配置类启用缓存注解。通过这些步骤,可以利用Spring的注解实现Redis缓存。
18 2
|
2天前
|
存储 缓存 NoSQL
Redis 缓存失效策略及其应用场景
Redis 缓存失效策略及其应用场景
12 1
|
3天前
|
存储 缓存 NoSQL
Redis是一种高性能的内存数据库,常用于高并发环境下的缓存解决方案
【6月更文挑战第18天】**Redis摘要:** 高性能内存数据库,擅长高并发缓存。数据存内存,访问迅速;支持字符串、列表等多元数据类型;具备持久化防止数据丢失;丰富命令集便于操作;通过节点集群实现数据分片与负载均衡,增强可用性和扩展性。理想的缓存解决方案。
18 1
|
1天前
|
缓存 NoSQL Java
在 Spring Boot 应用中使用 Spring Cache 和 Redis 实现数据查询的缓存功能
在 Spring Boot 应用中使用 Spring Cache 和 Redis 实现数据查询的缓存功能
11 0
|
7天前
|
存储 Prometheus 监控
Redis 调优指南:提高性能和稳定性的全面策略
Redis 调优指南:提高性能和稳定性的全面策略
9 0
|
11天前
|
缓存 NoSQL Java
Java一分钟之-Spring Data Redis:使用Redis做缓存
【6月更文挑战第10天】Spring Data Redis是Spring框架的一部分,简化了Java应用与Redis的集成,支持多种数据结构操作。本文介绍了其基本使用,包括添加依赖、配置Redis连接及使用RedisTemplate。还讨论了常见问题,如序列化、缓存穿透和雪崩,并提供解决方案。通过实战示例展示了缓存与数据库读写分离的实现,强调了Spring Data Redis在提升系统性能中的作用。
41 0
|
28天前
|
NoSQL Linux Redis
Redis -- 安装客户端redis-plus-plus
Redis -- 安装客户端redis-plus-plus
52 0