1. 过期键删除策略
如果一个键过期了，该怎么删除呢？有三种策略：
- 定时删除：在设置键的过期时间的时候，创建一个定时器，让定时器在键过期的时候，删除key-value。
- 惰性删除：每次再客户端请求键时，判断键是否过期，如果过期则删除。
- 定期删除：每隔一段时间，服务器就对数据库检查看是否有键过期，删除过期键。
定时删除是主动删除策略，能够及时删除过期键，及时释放过期键所占用的内存空间。但是对CPU的利用率并不友好，在过期键比较多时，长时间占用CPU。
惰性策略和定期策略都属于被动策略。惰性策略只有在获取键的时候才会处理过期键，对CPU是友好的。但是如果有些过期键长期没有使用，那么就一直占用内存，无法被删除。定期删除平衡了CPU的占用以及内存的占用，但是有一个难点就是无法确认时间间隔以及频率。因此redis采用惰性策略和定期策略来处理过期键。
1.1 惰性删除策略
redis在针对所有读写key的之前，都会执行一个函数expireIfNeeded：
int expireIfNeeded(redisDb *db, robj *key) {
// getExpire（db,key）函数取出键key的过期时间，如果key没有设置过期时间那么返回-1
mstime_t when = getExpire(db,key);
mstime_t now;
if (when < 0) return 0; /* No expire for this key key没有设置过期时间*/
// 如果服务器正在进行载入，那么过会儿再执行
if (server.loading) return 0;
//如果我们是正在执行lua脚本，那么必须先将脚本进行阻塞。
now = server.lua_caller ? server.lua_time_start : mstime();
// 附属节点并不主动删除 key，它只返回一个逻辑上正确的返回值
// 真正的删除操作要等待主节点发来删除命令时才执行，从而保证数据的同步
//这部分知识可以查看redis的主从同步
if (server.masterhost != NULL) return now > when;
// 运行到这里，表示键带有过期时间，并且服务器为主节点
/* Return when this key has not expired */
// 如果未过期，返回 0
if (now <= when) return 0;
/* 已过期的键的数量 */
server.stat_expiredkeys++;
// 向 AOF 文件和附属节点传播过期信息.当key过期时，DEL 操作也会传递给所有的AOF文件和附属节点
propagateExpire(db,key);
// 发送事件通知,关于redis的键事件通知和键空间通知，可以查询资料后面学习硬挨也会讲到
notifyKeyspaceEvent(REDIS_NOTIFY_EXPIRED,
"expired",key,db->id);
// 调用dbDelete(db,keu)将过期键从数据库中删除
return dbDelete(db,key);
}
流程就是：
在键的过期字典里获取键的过期时间，如果没有过期时间，则直接返回。如果有过期时间，比较系统当前时间与过期时间，如果已过期，则删除key。
1.2 定期删除策略
void activeExpireCycle(int type) {
// 默认每次处理的数据库数量
unsigned int dbs_per_call = REDIS_DBCRON_DBS_PER_CALL; //默认 REDIS_DBCRON_DBS_PER_CALL=16
// 函数开始的时间
long long start = ustime(), timelimit;
// 快速模式
if (type == ACTIVE_EXPIRE_CYCLE_FAST) {
/* Don't start a fast cycle if the previous cycle did not exited
* for time limt. Also don't repeat a fast cycle for the same period
* as the fast cycle total duration itself. */
// 如果上次函数没有触发 timelimit_exit ，那么不执行处理
if (!timelimit_exit) return;
// 如果距离上次执行未够一定时间，那么不执行处理
if (start < last_fast_cycle + ACTIVE_EXPIRE_CYCLE_FAST_DURATION*2) return;
// 运行到这里，说明执行快速处理，记录当前时间
last_fast_cycle = start;
}
/* We usually should test REDIS_DBCRON_DBS_PER_CALL per iteration, with
* two exceptions:
*
* 一般情况下，每次迭代（也就是每次调用这个函数）函数只处理 REDIS_DBCRON_DBS_PER_CALL 个数据库，
* 除非：
*
* 1) Don't test more DBs than we have.
* 当前数据库的数量小于 REDIS_DBCRON_DBS_PER_CALL
* 2) If last time we hit the time limit, we want to scan all DBs
* in this iteration, as there is work to do in some DB and we don't want
* expired keys to use memory for too much time.
* 如果上次处理遇到了时间上限，那么这次需要对所有数据库进行扫描，
* 这可以避免过多的过期键占用空间
*/
if (dbs_per_call > server.dbnum || timelimit_exit)//以服务器的数据库数量为准
dbs_per_call = server.dbnum;
/* We can use at max ACTIVE_EXPIRE_CYCLE_SLOW_TIME_PERC percentage of CPU time
* per iteration. Since this function gets called with a frequency of
* server.hz times per second, the following is the max amount of
* microseconds we can spend in this function. */
// 函数处理的微秒时间上限
// ACTIVE_EXPIRE_CYCLE_SLOW_TIME_PERC 默认为 25 ，也即是 25 % 的 CPU 时间
timelimit = 1000000*ACTIVE_EXPIRE_CYCLE_SLOW_TIME_PERC/server.hz/100;
timelimit_exit = 0;
if (timelimit <= 0) timelimit = 1;
// 如果是运行在快速模式之下
// 那么最多只能运行 FAST_DURATION 微秒
// 默认值为 1000 （微秒）
if (type == ACTIVE_EXPIRE_CYCLE_FAST)
timelimit = ACTIVE_EXPIRE_CYCLE_FAST_DURATION; /* in microseconds. */
// 遍历数据库
for (j = 0; j < dbs_per_call; j++) {
int expired;
// 指向要处理的数据库
redisDb *db = server.db+(current_db % server.dbnum);
/* Increment the DB now so we are sure if we run out of time
* in the current DB we'll restart from the next. This allows to
* distribute the time evenly across DBs. */
// 为 currrnt_DB 计数器加一，如果进入 do 循环之后因为超时而跳出
// 那么下次会直接从下个 currrnt_DB 开始处理。这样使得分配在每个数据库上处理时间比较平均
current_db++;
/* Continue to expire if at the end of the cycle more than 25%
* of the keys were expired. */
//如果每次循环清理的过期键是过期键的25%以上，那么就继续清理
do {
unsigned long num, slots;
long long now, ttl_sum;
int ttl_samples;
/* If there is nothing to expire try next DB ASAP. */
// 获取数据库中带过期时间的键的数量
// 如果该数量为 0 ，直接跳过这个数据库
if ((num = dictSize(db->expires)) == 0) {
db->avg_ttl = 0;
break;
}
// 获取数据库中键值对的数量
slots = dictSlots(db->expires);
// 当前时间
now = mstime();
/* When there are less than 1% filled slots getting random
* keys is expensive, so stop here waiting for better times...
* The dictionary will be resized asap. */
// 这个数据库的使用率低于 1% ，扫描起来太费力了（大部分都会 MISS）
// 跳过，等待字典收缩程序运行
if (num && slots > DICT_HT_INITIAL_SIZE &&
(num*100/slots < 1)) break;
/* The main collection cycle. Sample random keys among keys
* with an expire set, checking for expired ones.
*
* 样本计数器
*/
// 已处理过期键计数器
expired = 0;
// 键的总 TTL 计数器
ttl_sum = 0;
// 总共处理的键计数器
ttl_samples = 0;
// 每次最多只能检查 LOOKUPS_PER_LOOP 个键,默认是20
if (num > ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP)
num = ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP;
// 开始遍历数据库
while (num--) {
dictEntry *de;
long long ttl;
// 从 expires 中随机取出一个带过期时间的键
if ((de = dictGetRandomKey(db->expires)) == NULL) break;
// 计算 TTL
ttl = dictGetSignedIntegerVal(de)-now;
// 如果键已经过期，那么删除它，并将 expired 计数器增一
if (activeExpireCycleTryExpire(db,de,now)) expired++;
if (ttl < 0) ttl = 0;
// 累积键的 TTL
ttl_sum += ttl;
// 累积处理键的个数
ttl_samples++;
}
/* Update the average TTL stats for this database. */
// 为这个数据库更新平均 TTL 统计数据
if (ttl_samples) {
// 计算当前平均值
long long avg_ttl = ttl_sum/ttl_samples;
// 如果这是第一次设置数据库平均 TTL ，那么进行初始化
if (db->avg_ttl == 0) db->avg_ttl = avg_ttl;
/* Smooth the value averaging with the previous one. */
// 否则取数据库的上次平均 TTL 和今次平均 TTL 的平均值
db->avg_ttl = (db->avg_ttl+avg_ttl)/2;
}
/* We can't block forever here even if there are many keys to
* expire. So after a given amount of milliseconds return to the
* caller waiting for the other active expire cycle. */
// 如果过期键太多的话，我们不能用太长时间处理，所以这个函数执行一定时间之后就要返回，等待下一次循环
// 更新遍历次数
iteration++;
// 每遍历 16 次执行一次
if ((iteration & 0xf) == 0 && /* check once every 16 iterations. */
(ustime()-start) > timelimit)
{
// 如果遍历次数正好是 16 的倍数
// 并且遍历的时间超过了 timelimit，超时了
// 那么将timelimit_exit赋值为1，下一个if返回吧
timelimit_exit = 1;
}
// 已经超时了，返回
if (timelimit_exit) return;
/* We don't repeat the cycle if there are less than 25% of keys
* found expired in the current DB. */
// 如果删除的过期键少于当前数据库中过期键数量的 25 %，那么不再遍历。当然如果超过了25%,那说明过期键还很多，继续清理
} while (expired > ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP/4);
}
}
流程就是：
- 函数每次在一定数量的数据库中取出一定的随机键检查是否过期，过期则删除。
- 如果过期键太多的话，我们不能用太长时间处理，所以这个函数执行一定时间之后就要返回，等待下一次循环。而redis
2. 内存回收策略
Redis的内存回收策略是指在Redis的用于缓存的内存不足时，怎么处理需要新写入且需要申请额外空间的数据。
- noeviction
当内存不足以容纳新写入数据时，新写入操作会报错。 - allkeys-lru
当内存不足以容纳新写入数据时，在键空间中，移除最近最少使用的key。 - allkeys-random
当内存不足以容纳新写入数据时，在键空间中，随机移除某个key。 - volatile-lru
当内存不足以容纳新写入数据时，在设置了过期时间的键空间中，移除最近最少使用的key。 - volatile-random
当内存不足以容纳新写入数据时，在设置了过期时间的键空间中，随机移除某个key。 - volatile-ttl
当内存不足以容纳新写入数据时，在设置了过期时间的键空间中，有更早过期时间的key优先移除。
