Redis 的键管理

一、Redis 数据库管理

Redis 是一个键值对（key-value pair）的数据库服务器，其数据保存在 src/server.h/redisDb 中(网上很多帖子说在 redis.h 文件中，但是 redis 6.x版本目录中都没有这个文件。redisDb 结构应该在 server.h文件中)

typedef redisServer {
    ....
    
    // Redis数据库
    redisDb *db;
    
    ....
}

Redis 默认会创建 16 个数据库，每个数据库是独立互不影响。其默认的目标数据库是 0 号数据库，可以通过 select 命令来切换目标数据库。在 redisClient 结构中记录客户端当前的目标数据库：

typedef struct redisClient {

    // 套接字描述符
    int fd;

    // 当前正在使用的数据库
    redisDb *db;

    // 当前正在使用的数据库的 id （号码）
    int dictid;

    // 客户端的名字
    robj *name;             /* As set by CLIENT SETNAME */

} redisClient;

下面是客户端和服务器状态之间的关系实例，客户端的目标数据库目前为 1 号数据库：

通过修改 redisClient.db 的指针来指向不同数据库，这也就是 select 命令的实现原理。但是，到目前为止，Redis 仍然没有可以返回客户端目标数据库的命令。虽然在 redis-cli 客户端中输入时会显示：

redis> SELECT 1
Ok
redis[1]>

但是在其他语言客户端没有显示目标数据库的号端，所以在频繁切换数据库后，会导致忘记目前使用的是哪一个数据库，也容易产生误操作。因此要谨慎处理多数据库程序，必须要执行时，可以先显示切换指定数据库，然后再执行别的命令。

二、Redis 数据库键

2.1 数据库键空间

Redis 服务器中的每一个数据库是由一个 server.h/redisDb 结构来表示的，其具体结构如下：

typedef struct redisDb {
    //数据库键空间
    dict *dict;                 /* The keyspace for this DB */
    //键的过期时间，字典的值为过期事件 UNIX 时间戳
    dict *expires;              /* Timeout of keys with a timeout set */
    //正处于阻塞状态的键
    dict *blocking_keys;        /* Keys with clients waiting for data (BLPOP)*/
    //可以解除阻塞的键
    dict *ready_keys;           /* Blocked keys that received a PUSH */
    //正在被 WATCH 命令监视的键
    dict *watched_keys;         /* WATCHED keys for MULTI/EXEC CAS */
    //数据库号端
    int id;                     /* Database ID */
    //数据库键的平均 TTL，统计信息
    long long avg_ttl;          /* Average TTL, just for stats */
    //
    unsigned long expires_cursor; /* Cursor of the active expire cycle. */
    list *defrag_later;         /* List of key names to attempt to defrag one by one, gradually. */
} redisDb;

键空间和用户所见的数据库是直接对应：

• 键空间的 key 就是数据库的 key, 每个 key 都是一个字符串对象
• 键空间的 value 是数据库的 value, 每个 value 可以是字符串对象、列表对象和集合对象等等任意一种 Redis 对象

举个实例，若在空白数据库中执行一下命令：插入字符串对象、列表对象和哈希对象

# 插入一个字符串对象
redis> SET message "hello world"
OK
# 插入包含三个元素的列表对象
redis> RPUSH alphabet "a" "b" "c"
(integer)3
# 插入包含三个元素的哈希表对象
redis> HSET book name "Redis in Action"
(integer) 1
redis> HSET book author "Josiah L. Carlson"
(integer) 1
redis> HSET book publisher "Manning"
(integer) 1

所以说 redis 对数据的增删改查是通过操作 dict 来操作 Redis 中的数据

2.2 数据库键的过期

我们可以通过两种方式设置键的生命周期：

• 通过 EXPIRE 或者 PEXPIRE 命令来为数据库中的某个键设置生存时间（TTL，Time To Live）。在经过 TTL 个生存时间后，服务器会自动删除生存时间为0 的键。比如：

redis> set key value
OK
# 设置键的 TTL 为 5
redis> EXPIRE key 5
(integer)1

• 此外，客户端也可以通过 EXPIREAT 或者PEXPIREAT 命令，为数据库中的某个键设置过期时间（expire time）。过期时间是一个 UNIX 时间戳，当过期时间来临时，服务器就会自动从数据库中删除这个键。比如

redis> SET key value
OK
redis> EXPIREAT key 1377257300
(integer) 1
# 当前系统时间
redis> TIME
1)"1377257296"
# 过一段时间后，再查询key 
redis> GET key // 1377257300
(nil)

2.2.1 过期时间

redisDb 中的dict *dict 和 dict *expires 字典 分别保存了数据库中的键和键的过期时间，分别叫做键空间和过期字典。

• 过期字典的键是一个指向键空间中的某个键对象
• 过期字典的值是一个 long long 类型的整数，这个整数保存了键所指向的数据库键的过期时间

2.3 过期键的删除策略

对于已经过期的数据是如何删除这些过期键的呢？主要有两种方式：惰性删除和定期删除：

1.惰性删除

是指 Redis 服务器不主动删除过期的键值，而是通过访问键值时，检查当前的键值是否过期

• 如果过期则执行删除并返回 null
• 没有过期则正常访问值信息给客户端

惰性删除的源码在 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; 

    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;

    if (dictSize(db->expires) == 0 ||

       (de = dictFind(db->expires,key->ptr)) == NULL) return -1;

    serverAssertWithInfo(NULL,key,dictFind(db->dict,key->ptr) != NULL);

    return dictGetSignedIntegerVal(de);

}

2.定期删除

与惰性删除不同，定期删除是指 Redis 服务器会每隔一段时间就会检查一下数据库，看看是否有过期键可以清除，默认情况下，Redis 定期检查的频率是每秒扫描 10 次，这个值在 redis.conf 中的 "hz" , 默认是 10 ，可以进行修改。
定期删除的扫描并不是遍历所有的键值对，这样的话比较费时且太消耗系统资源。Redis 服务器采用的是随机抽取形式，每次从过期字典中，取出 20 个键进行过期检测，过期字典中存储的是所有设置了过期时间的键值对。如果这批随机检查的数据中有 25% 的比例过期，那么会再抽取 20 个随机键值进行检测和删除，并且会循环执行这个流程，直到抽取的这批数据中过期键值小于 25%，此次检测才算完成。

定期删除的源码在 expire.c/activeExpireCycle 方法中：

void activeExpireCycle(int type) {

    static unsigned int current_db = 0; /* 上次定期删除遍历到的数据库ID */

    static int timelimit_exit = 0;      

    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) {

                    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;

                }

            }

            /* 判断过期键删除数量是否超过 25% */

        } while (expired > ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP/4);

    }

    // .......

}

以上就是Redis 的删除策略。下面来看一个面试题：

面试题：你知道 Redis 内存淘汰策略和键的删除策略的区别吗？

Redis 内存淘汰策略

我们可以通过 config get maxmemory-policy 命令来查看当前 Redis 的内存淘汰策略：

127.0.0.1:6379> config get maxmemory-policy

1) "maxmemory-policy"

2) "noeviction"

当前服务器设置的是 noeviction 类型的，对于 redis 6.x版本，主要有以下几种内存淘汰策略

• noeviction：不淘汰任何数据，当内存不足时，执行缓存新增操作会报错，它是 Redis 默认内存淘汰策略。
• allkeys-lru：淘汰整个键值中最久未使用的键值。
• allkeys-random：随机淘汰任意键值。
• volatile-lru：淘汰所有设置了过期时间的键值中最久未使用的键值。
• volatile-random：随机淘汰设置了过期时间的任意键值。
• volatile-ttl：优先淘汰更早过期的键值。
• volatile-lfu: 淘汰所有设置了过期时间的键值中最少使用的键值。
• alkeys-lfu: 淘汰整个键值中最少使用的键值

也就是 alkeys 开头的表示从所有键值中淘汰相关数据，而 volatile 表示从设置了过期键的键值中淘汰数据。

Redis 内存淘汰算法

内存淘汰算法主要分为 LRU 和 LFU 淘汰算法

LRU(Least Recently Used) 淘汰算法

是一种常用的页面置换算法，LRU 是基于链表结构实现，链表中的元素按照操作顺序从前往后排列。最新操作的键会被移动到表头，当需要进行内存淘汰时，只需要删除链表尾部的元素。

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

LFU(Least Frequently Used)淘汰算法

根据总访问次数来淘汰数据，核心思想是如果数据过去被访问多次，那么将来被访问的频率也更高

参考资料

《Redis 设计与实现》
https://kaiwu.lagou.com/course/courseInfo.htm?courseId=59#/detail/pc?id=1779