Redis过期键处理策略

发表于 | 更新于: | 分类于 ， |
字数统计: 2.8k | 阅读时长 ≈ 10

Redis Expire Key基础

redis数据库在数据库服务器中使用了 redisDb 数据结构，结构如下：

1
2
3
4
5
6
7
8
9
10
typedef struct redisDb {
     dict *dict;            /* 键空间 key space */
     dict *expires;         /* 过期字典 */
     dict *blocking_keys;   /* Keys with clients waiting for data (BLPOP) */
     dict *ready_keys;      /* Blocked keys that received a PUSH */
     dict *watched_keys;    /* WATCHED keys for MULTI/EXEC CAS */
     struct evictionPoolEntry *eviction_pool; /* Eviction pool of keys */
     int id;                /* Database ID */
     long long avg_ttl;     /* Average TTL, just for stats */
} redisDb;

其中:

  • 键空间(key space):
    dict字典用来保存数据库中的所有键值对

  • 过期字典(expires):
    保存数据库中所有键的过期时间，过期时间用UNIX时间戳表示，且值为long long整数

设置过期时间命令

  • EXPIRE <key> <ttl> 命令用于将键key的过期时间设置为ttl秒之后

  • PEXPIRE <key> <ttl> 命令用于将键key的过期时间设置为ttl毫秒之后

  • EXPIREAT <key> <timesramp> 命令用于将key的过期时间设置为timrestamp所指定的秒数时间戳

  • PEXPIREAT <key> <timesramp> 命令用于将key的过期时间设置为timrestamp所指定的毫秒数时间戳

设置过期时间：

1
2
3
4
redis> set Ccww   5 2 0  
ok  
redis> expire Ccww 5  
ok

使用redisDb结构存储数据图表示：

过期时间保存以及判定

过期键的判定，其实通过过期字典进行判定，步骤：

  • 检查给定键是否存在于过期字典，如果存在，取出键的过期时间

  • 通过判断当前UNIX时间戳是否大于键的过期时间，是的话，键已过期，相反则键未过期。

过期键删除策略

定时删除

在设置键的过期时间的同时，创建一个定时任务，当键达到过期时间时，立即执行对键的删除操作.

  • 优点
    对内存友好，定时删除策略可以保证过期键会尽可能快地被删除，并释放国期间所占用的内存

  • 缺点
    对cpu时间不友好，在过期键比较多时，删除任务会占用很大一部分cpu时间，在内存不紧张但cpu时间紧张的情况下，将cpu时间用在删除和当前任务无关的过期键上，影响服务器的响应时间和吞吐量

惰性删除

放任键过期不管，但在每次从键空间获取键时，都检查取得的键是否过期，如果过期的话，就删除该键，如果没有过期，就返回该键

  • 优点
    对cpu时间友好，在每次从键空间获取键时进行过期键检查并是否删除，删除目标也仅限当前处理的键，这个策略不会在其他无关的删除任务上花费任何cpu时间。

  • 缺点
    对内存不友好，过期键过期也可能不会被删除，导致所占的内存也不会释放。甚至可能会出现内存泄露的现象，当存在很多过期键，而这些过期键又没有被访问到，这会可能导致它们会一直保存在内存中，造成内存泄露。

定期删除

由于定时删除会占用太多cpu时间，影响服务器的响应时间和吞吐量, 而惰性删除浪费太多内存，有内存泄露的危险，所以出现一种整合和折中这两种策略的定期删除策略:

  1. 定期删除策略每隔一段时间执行一次删除过期键操作，并通过限制删除操作执行的时长和频率来减少删除操作对CPU时间的影响;

  2. 至于要删除多少过期键，以及要检查多少个数据库，则由算法决定；

  3. 定时删除策略有效地减少了因为过期键带来的内存浪费;

定时删除策略难点就是确定删除操作执行的时长和频率：

  • 删除操作执行得太频繁。或者执行时间太长，定期删除策略就会退化成为定时删除策略，以至于将cpu时间过多地消耗在删除过期键上。   
  • 相反，则与惰性删除策略一样，出现浪费内存的情况。

所以使用定期删除策略，需要根据服务器的情况合理地设置删除操作的执行时长和执行频率。

过期键删除策略实现

  Redis服务器结合惰性删除和定期删除两种策略一起使用，通过这两种策略之间的配合使用，使得服务器可以在合理使用CPU时间和浪费内存空间取得平衡点。   

惰性删除策略的实现

  Redis在执行任何读写命令时都会先找到这个key，惰性删除就作为一个切入点放在查找key之前，如果key过期了就删除这个key。
  

1
2
3
4
5
6
7
8
9
10
robj *lookupKeyRead(redisDb *db, robj *key) {
          robj *val;
	 expireIfNeeded(db,key); // 切入点
	 val = lookupKey(db,key);
	 if (val == NULL)
	  server.stat_keyspace_misses++;
	 else
	  server.stat_keyspace_hits++;
	 return val;
}

通过expireIfNeeded函数对输入键进行检查是否删除:

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
int expireIfNeeded(redisDb *db, robj *key) {
     /* 取出键的过期时间 */
    mstime_t when = getExpire(db,key);
    mstime_t now;
    
     /* 没有过期时间返回0*/
    if (when < 0) return 0; /* No expire for this key */

    /* 服务器loading时*/
    if (server.loading) return 0;

    /* 根据一定规则获取当前时间*/
    now = server.lua_caller ? server.lua_time_start : mstime();
    /* 如果当前的是从(Slave)服务器
     * 0 认为key为无效
     * 1 if we think the key is expired at this time. 
     * */
    if (server.masterhost != NULL) return now > when;

     /* key未过期，返回 0 */
    if (now <= when) return 0;

     /* 删除键 */
    server.stat_expiredkeys++;
    propagateExpire(db,key,server.lazyfree_lazy_expire);
    notifyKeyspaceEvent(NOTIFY_EXPIRED,
        "expired",key,db->id);
    return server.lazyfree_lazy_expire ? dbAsyncDelete(db,key) :
                                         dbSyncDelete(db,key);
}

定期删除策略的实现

  key的定期删除会在Redis的周期性执行任务（serverCron，默认每100ms执行一次）中进行，而且是发生Redis的master节点，因为slave节点会通过主节点的DEL命令同步过来达到删除key的目的。   

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
for (j = 0; j < dbs_per_call; j++) {
 int expired;
 redisDb *db = server.db+(current_db % server.dbnum);
 
 current_db++;
 
 /* 超过25％的key已过期，则继续. */
 do {
  unsigned long num, slots;
  long long now, ttl_sum;
  int ttl_samples;
 
  /* 如果该db没有设置过期key，则继续看下个db*/
  if ((num = dictSize(db->expires)) == 0) {
   db->avg_ttl = 0;
   break;
  }
  slots = dictSlots(db->expires);
  now = mstime();
 
  /*但少于1%时，需要调整字典大小*/
  if (num && slots > DICT_HT_INITIAL_SIZE &&
   (num*100/slots < 1)) break;
 
  expired = 0;
  ttl_sum = 0;
  ttl_samples = 0;
 
  if (num > ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP)
   num = ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP;// 20
 
  while (num--) {
   dictEntry *de;
   long long ttl;
 
   if ((de = dictGetRandomKey(db->expires)) == NULL) break;
   ttl = dictGetSignedIntegerVal(de)-now;
   if (activeExpireCycleTryExpire(db,de,now)) expired++;
   if (ttl > 0) {
    /* We want the average TTL of keys yet not expired. */
    ttl_sum += ttl;
    ttl_samples++;
   }
  }
 
  /* Update the average TTL stats for this database. */
  if (ttl_samples) {
   long long avg_ttl = ttl_sum/ttl_samples;
 
   /样本获取移动平均值 */
   if (db->avg_ttl == 0) db->avg_ttl = avg_ttl;
   db->avg_ttl = (db->avg_ttl/50)*49 + (avg_ttl/50);
  }
  iteration++;
  if ((iteration & 0xf) == 0) { /* 每迭代16次检查一次 */
   long long elapsed = ustime()-start;
 
   latencyAddSampleIfNeeded("expire-cycle",elapsed/1000);
   if (elapsed > timelimit) timelimit_exit = 1;
  }
 /* 超过时间限制则退出*/
  if (timelimit_exit) return;
  /* 在当前db中，如果少于25%的key过期，则停止继续删除过期key */
 } while (expired > ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP/4);
}

依次遍历每个db（默认配置数是16），针对每个db，每次循环随机选择20个（ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP）key判断是否过期，如果一轮所选的key少于25%过期，则终止迭代，此外在迭代过程中如果超过了一定的时间限制则终止过期删除这一过程。

Redis采用的过期策略

redis 过期策略是：定期删除 + 惰性删除

假设 redis 里放了 10w 个 key，都设置了过期时间，你每隔几百毫秒，就检查 10w 个 key，那 redis 基本上就死了，cpu 负载会很高的，消耗在你的检查过期 key 上了。所以，这里可不是每隔 100ms 就遍历所有的设置过期时间的 key，那样就是一场性能上的灾难。实际上 redis 是每隔 100ms 随机抽取一些 key 来检查和删除的。

但是问题是，定期删除可能会导致很多过期 key 到了时间并没有被删除掉，那咋整呢？所以就需要结合惰性删除。

但是实际上这还是有问题的，如果定期删除漏掉了很多过期 key，然后你也没及时去查，也就没走惰性删除，此时会怎么样？如果大量过期 key 堆积在内存里，导致 redis 内存块耗尽了，咋整？

答案是：走内存淘汰机制

内存淘汰机制

redis 内存淘汰机制有以下几个：

  • noeviction 当内存不足以容纳新写入数据时，新写入操作会报错，这个一般没人用吧，实在是太恶心了

  • allkeys-lru 当内存不足以容纳新写入数据时，在键空间中，移除最近最少使用的 key（这个是最常用的）；

  • allkeys-random 当内存不足以容纳新写入数据时，在键空间中，随机移除某个 key，这个一般没人用吧，为啥要随机，肯定是把最近最少使用的 key 给干掉啊；

  • volatile-lru 当内存不足以容纳新写入数据时，在设置了过期时间的键空间中，移除最近最少使用的 key（这个一般不太合适）；

  • volatile-random 当内存不足以容纳新写入数据时，在设置了过期时间的键空间中，随机移除某个key；

  • volatile-ttl 当内存不足以容纳新写入数据时，在设置了过期时间的键空间中，有更早过期时间的 key 优先移除；

设置方式：

1
config set maxmemory-policy volatile-lru

AOF、RDB和复制功能对过期键的处理

RDB

  • 生成RDB文件
    程序会数据库中的键进行检查，已过期的键不会保存到新创建的RDB文件中

  • 载入RDB文件

    • 主服务载入RDB文件，会对文件中保存的键进行检查会忽略过期键加载未过期键
    • 从服务器载入RDB文件，会加载文件所保存的所有键（过期和未过期的），但从主服务器同步数据同时会清空从服务器的数据库。

AOF

  • AOF文件写入
    当过期键被删除后，会在AOF文件增加一条DEL命令，来显式地记录该键已被删除。

  • AOF重写
    已过期的键不会保存到重写的AOF文件中

复制

 当服务器运行在复制模式下时，从服务器的过期键删除动作由主服务器控制的，这样的好处主要为了保持主从服务器数据一致性：

  • 主服务器在删除一个过期键之后，会显式地向所有的从服务器发送一个DEL命令，告知从服务器删除这个过期键；

  • 从服务器在执行客户端发送的读取命令时，即使碰到过期键也不会将过期键删除，不作任何处理。只有接收到主服务器 DEL命令后，从服务器进行删除处理。

参考文档

[1] 当遇到美女面试官之如何理解Redis的Expire Key(过期键)

[2] Redis的过期策略及内存淘汰机制