一、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
