redis入门第六课（过期键删除策略与内存回收策略） redis入门第六课：过期键删除策

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 keykey没有设置过期时间*/ // 如果服务器正在进行载入，那么过会儿再执行 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); }

【redis入门第六课（过期键删除策略与内存回收策略）】流程就是：
在键的过期字典里获取键的过期时间，如果没有过期时间，则直接返回。如果有过期时间，比较系统当前时间与过期时间，如果已过期，则删除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); } }

流程就是：