6. Redis在内存用完时会怎么办？以及Redis如何处理已过期的数据？

楔子

在某些极端情况下，软件为了能正常运行会做一些保护性的措施，比如运行内存超过最大值之后的处理，以及键值过期之后的处理等等，都属于此类问题，而专业而全面的回答这些问题恰好是一个工程师所具备的优秀品质。

那么下面我们就来探讨一下。

Redis内存用完了会怎么办？

Redis 的内存用完指的是 Redis 使用的运行内存超过了 Redis 设置的最大内存，此值可以通过 Redis 的配置文件 redis.conf 进行设置，设置项为 maxmemory，我们可以使用 config get maxmemory 来查看设置的最大运行内存，如下所示：

127.0.0.1:6379> config get maxmemory
1) "maxmemory"
2) "0"
127.0.0.1:6379> 

config get是专门用来获取配置的，config set是设置配置的。我们返回的结果为0，表示没有内存大小限制，直到耗尽机器中所有的内存为止，这是 Redis 服务器端在 64 位操作系统下的默认值。

32 位操作系统，默认最大内存值为 3GB。

当 Redis 的内存用完之后就会触发 Redis 的内存淘汰策略，执行流程如下图所示：

最大内存的检测源码位于 server.c 中，核心代码如下：

int processCommand(client *c) {
    // 最大内存检测
    if (server.maxmemory && !server.lua_timedout) {
        int out_of_memory = freeMemoryIfNeededAndSafe() == C_ERR;
        if (server.current_client == NULL) return C_ERR;
        if (out_of_memory &&
            (c->cmd->flags & CMD_DENYOOM ||
             (c->flags & CLIENT_MULTI && c->cmd->proc != execCommand))) {
            flagTransaction(c);
            addReply(c, shared.oomerr);
            return C_OK;
        }
    }
    // 忽略其他代码
}

Redis 内存淘汰策略可以使用 config get maxmemory-policy 命令来查看，如下所示：

127.0.0.1:6379> config get maxmemory-policy
1) "maxmemory-policy"
2) "noeviction"
127.0.0.1:6379> 

从上述结果可以看出此 Redis 服务器采用的是 noeviction 策略，此策略表示当运行内存超过最大设置内存时，不淘汰任何数据，但新增操作会报错。此策略为 Redis 默认的内存淘汰策略，此值可通过修改 redis.conf 文件进行修改。

关于淘汰策略，在前面介绍Redis配置文件的博客中，写的比较详细了。算了，还是再粘过来一次吧。

• volatile-lru：使用LRU(最近最少使用)策略移除keys，只针对过期的keys
• allkeys-lru：使用LRU(最近最少使用)策略移除keys
• volatile-lfu：使用LFU(最近最不常使用)策略移除keys，只针对过期的keys
• allkeys-lru：使用LFU(最近最不常使用)策略移除keys
• volatile-random：随机移除一个过期的key
• allkeys-random：随机移除一个任意key
• volatile-ttl：移除ttl值(过期时间)最少的key，即最快要过期的key
• noeviction：不移除任意key，仅仅在写操作的时候返回一个error

Redis 的内存最大值和内存淘汰策略都可以通过配置文件进行修改，或者是使用命令行工具进行修改。使用命令行工具进行修改的优点是操作简单，成功执行完命令之后设置的策略就会生效，我们可以使用 confg set 的方式进行设置，但它的缺点是不能进行持久化，也就是当 Redis 服务器重启之后设置的策略就会丢失。另一种方式就是为配置文件修改的方式，此方式虽然较为麻烦，修改完之后要重启 Redis 服务器才能生效，但优点是可持久化，重启 Redis 服务器设置不会丢失。

关于LRU和LFU

内存淘汰策略决定了内存淘汰算法，从以上八种内存淘汰策略可以看出，它们中虽然具体的实现细节不同，但主要的淘汰算法有两种：LRU 算法和 LFU 算法，我们分别介绍一下。

LRU算法

LRU 全称是 Least Recently Used 译为最近最少使用，是一种常用的页面置换算法，选择最近最久未使用的页面予以淘汰。

1. LRU 算法实现

LRU 算法需要基于链表结构，链表中的元素按照操作顺序从前往后排列，最新操作的键会被移动到表头，当需要内存淘汰时，只需要删除链表尾部的元素即可。

2. 近似LRU 算法

Redis 使用的是一种近似 LRU 算法，目的是为了更好的节约内存，它的实现方式是给现有的数据结构添加一个额外的字段，用于记录此键值的最后一次访问时间，Redis 内存淘汰时，会使用随机采样的方式来淘汰数据，它是随机取 5 个值 (此值可配置) ，然后淘汰最久没有使用的那个。

3. LRU 算法缺点

LRU 算法有一个缺点，比如说很久没有使用的一个键值，如果最近被访问了一次，那么它就不会被淘汰，即使它是使用次数最少的缓存，那它也不会被淘汰，因此在 Redis 4.0 之后引入了 LFU 算法，下面我们一起来看。

LFU算法

LFU 全称是 Least Frequently Used 翻译为最不常用的，最不常用的算法是根据总访问次数来淘汰数据的，它的核心思想是"如果数据过去被访问多次，那么将来被访问的频率也更高"。 LFU 解决了偶尔被访问一次之后，数据就不会被淘汰的问题，相比于 LRU 算法也更合理一些。 在 Redis 中每个对象头中记录着 LFU 的信息，源码如下：

typedef struct redisObject {
    unsigned type:4;
    unsigned encoding:4;
    unsigned lru:LRU_BITS; /* LRU time (relative to global lru_clock) or
                            * LFU data (least significant 8 bits frequency
                            * and most significant 16 bits access time). */
    int refcount;
    void *ptr;
} robj;

在 Redis 中 LFU 存储分为两部分，16 bit 的 ldt(last decrement time) 和 8 bit 的 logc(logistic counter)。

• 1. logc 是用来存储访问频次, 8 bit 能表示的最大整数值为 255，它的值越小表示使用频率越低，越容易淘汰；
• 2. ldt 是用来存储上一次 logc 的更新时间。

至于 Redis 到底采用的是近 LRU 算法还是 LFU 算法，完全取决于内存淘汰策略的类型配置。

Redis如何处理已经过期的数据？

介绍完 Redis 内存用完之后的内存淘汰策略之后，我们再来看看 Redis 的键值过期之后的数据处理。这两者是不同的，前者是在内存满了的时候，对数据进行清理，算是异常情况；而后者是对键值过期之后的数据处理，算是正常情况下的数据清理。

问：Redis 如何处理已过期的数据？

在 Redis 中维护了一个过期字典，会将所有已经设置了过期时间的键值全部存储到此字典中，我们使用设置过期时间的命令来举个例子，命令如下：

127.0.0.1:6379> set name hanser ex 30
OK
127.0.0.1:6379> 

此命令表示 30s 之后键值为 name:hanser 的数据将会过期，其中 ex 是 expire 的缩写，也就是过期、到期的意思。

过期时间除了上面的那种字符类型的直接设置之外，还可以使用 expire key seconds 的方式直接设置，示例如下：

127.0.0.1:6379> set age 28  # 先设置，此时默认永不过期
OK
127.0.0.1:6379> expire age 20  # 添加一个过期时间
(integer) 1
127.0.0.1:6379> 

所以我们根据一个键获取对应值(简单来说就是获取键值)时，Redis会先判断这个键值是否存在于过期字典中，如果没有的话，表示键值没有设置过期时间(永不过期)，于是直接返回数据；如果键值在过期字典中，那么会判断当前时间是否小于过期时间，如果是，那么说明没有过期会正常返回，反之表示数据已过期，于是会删除该键值并返回nil。执行流程如下：

这是键值数据的获取流程，同时也是过期键值的判断和删除的流程。

知识扩展

和此知识点相关的面试题还有以下这些：

• 常用的删除策略有哪些？Redis 使用了什么删除策略？
• Redis 中是如何存储过期键的？

删除策略

常见的过期策略，有以下三种：

• 1. 定时删除
• 2. 惰性删除
• 3. 定期删除

1. 定时删除

在设置键值过期时间时，创建一个定时事件，当过期时间到达时，由事件处理器自动执行键的删除操作。

• 优点：保证内存可以被尽快的释放。
• 缺点：在 Redis 高负载的情况下或有大量过期键需要同时处理时，会造成 Redis 服务器卡顿，影响主业务执行。

2. 惰性删除

不主动删除过期键，每次从数据库获取键值时判断是否过期，如果过期则删除键值，并返回 null。

• 优点：因为每次访问时，才会判断过期键，所以此策略只会使用很少的系统资源。
• 缺点：系统占用空间删除不及时，导致空间利用率降低，造成了一定的空间浪费。

Redis 中惰性删除的源码位于 src/db.c 文件的 expireIfNeeded 方法中，源码如下：

int expireIfNeeded(redisDb *db, robj *key) {
    // 判断键是否过期
    if (!keyIsExpired(db,key)) return 0;
    if (server.masterhost != NULL) return 1;
    /* 删除过期键 */
    // 增加过期键个数
    server.stat_expiredkeys++;
    // 传播键过期的消息
    propagateExpire(db,key,server.lazyfree_lazy_expire);
    notifyKeyspaceEvent(NOTIFY_EXPIRED,
        "expired",key,db->id);
    // server.lazyfree_lazy_expire 为 1 表示异步删除（懒空间释放），反之同步删除
    return server.lazyfree_lazy_expire ? dbAsyncDelete(db,key) :
                                         dbSyncDelete(db,key);
}
// 判断键是否过期
int keyIsExpired(redisDb *db, robj *key) {
    mstime_t when = getExpire(db,key);
    if (when < 0) return 0; /* No expire for this key */
    /* Don't expire anything while loading. It will be done later. */
    if (server.loading) return 0;
    mstime_t now = server.lua_caller ? server.lua_time_start : mstime();
    return now > when;
}
// 获取键的过期时间
long long getExpire(redisDb *db, robj *key) {
    dictEntry *de;
    /* No expire? return ASAP */
    if (dictSize(db->expires) == 0 ||
       (de = dictFind(db->expires,key->ptr)) == NULL) return -1;
    /* The entry was found in the expire dict, this means it should also
     * be present in the main dict (safety check). */
    serverAssertWithInfo(NULL,key,dictFind(db->dict,key->ptr) != NULL);
    return dictGetSignedIntegerVal(de);
}

所有对数据库的读写命令在执行之前，都会调用 expireIfNeeded 方法判断键值是否过期，过期则会从数据库中删除，反之则不做任何处理。

惰性删除执行流程，如下图所示：

3. 定期删除

每隔一段时间检查一次数据库，随机删除一些过期键。 Redis 默认每秒进行 10 次过期扫描，此配置可通过 Redis 的配置文件 redis.conf 进行配置，配置键为 hz， 它的默认值是 hz 10 。 需要注意的是：Redis 每次扫描并不是遍历过期字典中的所有键，而是采用随机抽取判断并删除过期键的形式执行的。

定期删除流程如下：

• 1. 从过期字典中随机取出 20 个键；
• 2. 删除这 20 个键中过期的键；
• 3. 如果过期 key 的比例超过 25% ，重复步骤 1。

同时为了保证过期扫描不会出现循环过度，导致线程卡死现象，算法还增加了扫描时间的上限，默认不会超过 25ms。

定期删除执行流程，如下图所示：

• 优点：通过限制删除操作的时长和频率，来减少删除操作对 Redis 主业务的影响，同时也能删除一部分过期的数据减少了过期键对空间的无效占用。
• 缺点：内存清理方面没有定时删除效果好，同时没有惰性删除使用的系统资源少。

Redis 中定期删除的核心源码在 src/expire.c 文件下的 activeExpireCycle 方法中，源码如下：

void activeExpireCycle(int type) {
    static unsigned int current_db = 0; /* 上次定期删除遍历到的数据库 ID */
    static int timelimit_exit = 0;      /* Time limit hit in previous call? */
    static long long last_fast_cycle = 0; /* 上一次执行快速定期删除的时间点 */
    int j, iteration = 0;
    int dbs_per_call = CRON_DBS_PER_CALL; // 每次定期删除，遍历的数据库的数量
    long long start = ustime(), timelimit, elapsed;
    if (clientsArePaused()) return;
    if (type == ACTIVE_EXPIRE_CYCLE_FAST) {
        if (!timelimit_exit) return;
        // ACTIVE_EXPIRE_CYCLE_FAST_DURATION 是快速定期删除的执行时长
        if (start < last_fast_cycle + ACTIVE_EXPIRE_CYCLE_FAST_DURATION*2) return;
        last_fast_cycle = start;
    }
    if (dbs_per_call > server.dbnum || timelimit_exit)
        dbs_per_call = server.dbnum;
    // 慢速定期删除的执行时长
    timelimit = 1000000*ACTIVE_EXPIRE_CYCLE_SLOW_TIME_PERC/server.hz/100;
    timelimit_exit = 0;
    if (timelimit <= 0) timelimit = 1;
    if (type == ACTIVE_EXPIRE_CYCLE_FAST)
        timelimit = ACTIVE_EXPIRE_CYCLE_FAST_DURATION; /* 删除操作的执行时长 */
    long total_sampled = 0;
    long total_expired = 0;
    for (j = 0; j < dbs_per_call && timelimit_exit == 0; j++) {
        int expired;
        redisDb *db = server.db+(current_db % server.dbnum);
        current_db++;
        do {
            // .......
            expired = 0;
            ttl_sum = 0;
            ttl_samples = 0;
            // 每个数据库中检查的键的数量
            if (num > ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP)
                num = ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP;
            // 从数据库中随机选取 num 个键进行检查
            while (num--) {
                dictEntry *de;
                long long ttl;
                if ((de = dictGetRandomKey(db->expires)) == NULL) break;
                ttl = dictGetSignedInteger
                // 过期检查，并对过期键进行删除
                if (activeExpireCycleTryExpire(db,de,now)) expired++;
                if (ttl > 0) {
                    /* We want the average TTL of keys yet not expired. */
                    ttl_sum += ttl;
                    ttl_samples++;
                }
                total_sampled++;
            }
            total_expired += expired;
            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);
            }
            if ((iteration & 0xf) == 0) { /* check once every 16 iterations. */
                elapsed = ustime()-start;
                if (elapsed > timelimit) {
                    timelimit_exit = 1;
                    server.stat_expired_time_cap_reached_count++;
                    break;
                }
            }
            /* 每次检查只删除 ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP/4 个过期键 */
        } while (expired > ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP/4);
    }
    // .......
}

activeExpireCycle 方法在规定的时间，分多次遍历各个数据库，从过期字典中随机检查一部分过期键的过期时间，删除其中的过期键。

这个函数有两种执行模式，一个是快速模式一个是慢速模式，体现是代码中的 timelimit 变量，这个变量是用来约束此函数的运行时间的。快速模式下 timelimit 的值是固定的，等于预定义常量 ACTIVE_EXPIRE_CYCLE_FAST_DURATION，慢速模式下，这个变量的值是通过 1000000 * ACTIVE_EXPIRE_CYCLE_SLOW_TIME_PERC / server.hz / 100 计算的。

如果只使用惰性删除会导致删除数据不及时造成一定的空间浪费，又因为 Redis 本身的主线程是单线程执行的，如果因为删除操作而影响主业务的执行就得不偿失了，为此 Redis 需要制定多个过期删除策略：惰性删除加定期删除的过期策略，来保证 Redis 能够及时并高效的删除 Redis 中的过期键。

过期键

过期键存储在 redisDb 结构中，它的源码位于 src/server.h 文件中：

// 源码基于 Redis 5.x
typedef struct redisDb {
    dict *dict;                 /* 数据库键空间，存放着所有的键值对 */
    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 */
    int id;                     /* Database ID */
    long long avg_ttl;          /* Average TTL, just for stats */
    list *defrag_later;         /* List of key names to attempt to defrag one by one, gradually. */
} redisDb;

总结

这次我们介绍了三种常见的删除策略：定时删除、惰性删除、定期删除，其中定时删除比较消耗系统性能，惰性删除不能及时的清理过期数据从而导致了一定的空间浪费，为了兼顾存储空间和性能，Redis 采用了惰性删除加定期删除的组合删除策略，我们还通过 Redis 的源码分析了 Redis 各个删除策略的执行流程。当我们明白了 Redis 的过期删除知识之后，再去理解它与 Redis 内存淘汰的区别就显得非常容易了。