标签：删除 REDIS redis 源码 dict 惰性 key pool 内存
本文浅显的谈谈redis删除key的源码部分，希望本篇文章对于学习redis并且看源码的你能够起到抛砖引玉的作用，并在此记下自己阅读源码的足迹。
本文主要由以下几个部分组成
一、为什么要删除key？
二、内存淘汰的策略主要有哪些？
三、删除key的时机或者说手段有哪些？
四、删除key的源码整体脉络
五、源码的阅读
ANSWER 一
首先，为什么要删除key呢？这是因为redis是基于内存的数据库，计算机的内存容量是有限的，试想你一直往里面写入数据而没有一定的策略去删除你写的数据，内存早晚会被用完的，所以有必要删除删除那些老的数据，给新插入的数据腾挪地方。有的同学可能会说redis集群是可以扩展的，这样我就不用删除旧数据，我可以一直加机器解决内存不足的问题。这种方式显然是行不通的，因为你基于hash的方法分发数据，可能会导致数据失衡，从而导致某台服务器过载。所以就有必要对旧数据(过期key)进行删除。
ANSWER 二
既然要对key进行删除，我们就要有一定的策略进行删除，而不是随意的进行删除。redis中给出了以下策略用于淘汰key
// 根据lru算法删除带有过期时间的key
1】volatile-lru -> remove the key with an expire set using an LRU algorithm
// 根据lru算法删除任意的key
2】allkeys-lru -> remove any key accordingly to the LRU algorithm
// 随机删除带有过期时间的key
3】volatile-random -> remove a random key with an expire set
// 随机删除任何一个key
4】 allkeys-random -> remove a random key, any key
// 删除ttl最近的key
5】 volatile-ttl -> remove the key with the nearest expire time (minor TTL)
// 不删
6】noeviction -> don’t expire at all, just return an error on write operations
问题：你所在的公司用了哪种策略进行key的删除，为什么要用这种策略呢？可以探讨一番。
ANSWER 三
以上说了key的淘汰策略有哪些，也就是我们要删除key的时候要遵守的规则，并按照这个规则执行的key删除。那么策略有了，删除key的时机或者方式有哪些呢？在redis中有三个时机删除key。1、定时删除 2、定期删除 3、惰性删除。 redis目前删除的时机是 定期删除+惰性删除。至于这三个时机有什么优缺点，自己查阅相关书籍就能找到答案【redis设计与实现 P107】
ANSWER 四
本篇文章只讲惰性删除，也就是当执行命令时进行key的删除。这里给出执行命令时删除key的一个大致脉络，也就是函数的调用流程
客户端发送请求，redis服务端最终会调用这个函数处理客户端的命令请求
------------processCommand(redisClient *c)
在处理命令时，会调用这个函数进行内存释放，也就是进行key的删除，返回删除成功or失败
--------------freeMemoryIfNeeded（）
------------evictionPoolPopulate（dict, db->dict, db->eviction_pool）得到要删除的key
---------estimateObjectIdleTime(o) 计算key的过期时间
在对key惰性删除的时候，基本上调用上述四个函数。在讲解具体函数之前，我们还是来熟悉下几个数据结构
/*
* 哈希表节点
*/
typedef struct dictEntry {
// 键
void *key;
// 值
union {
void *val;
uint64_t u64;
int64_t s64;
} v;
// 指向下个哈希表节点，形成链表
struct dictEntry *next;
} dictEntry;
typedef struct redisObject {
// 类型
unsigned type:4;
// 编码
unsigned encoding:4;
// 对象最后一次被访问的时间
unsigned lru:REDIS_LRU_BITS; /* lru time (relative to server.lruclock) */
// 引用计数
int refcount;
// 指向实际值的指针
void *ptr;
} robj;
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 */
struct evictionPoolEntry *eviction_pool; /* Eviction pool of keys */
// 数据库号码
int id; /* Database ID */
// 数据库的键的平均 TTL ，统计信息
long long avg_ttl; /* Average TTL, just for stats */
} redisDb;
这个就是存储要删除key的数据结构
struct evictionPoolEntry {
unsigned long long idle; /* Object idle time. */
sds key; /* Key name. */
};
ANSWER 五
下面我们依次讲解上述的几个函数
/* If this function gets called we already read a whole
* command, arguments are in the client argv/argc fields.
* processCommand() execute the command or prepare the
* server for a bulk read from the client.
*
* 这个函数执行时，我们已经读入了一个完整的命令到客户端，
* 这个函数负责执行这个命令，
* 或者服务器准备从客户端中进行一次读取。
*
* If 1 is returned the client is still alive and valid and
* other operations can be performed by the caller. Otherwise
* if 0 is returned the client was destroyed (i.e. after QUIT).
*
* 如果这个函数返回 1 ，那么表示客户端在执行命令之后仍然存在，
* 调用者可以继续执行其他操作。
* 否则，如果这个函数返回 0 ，那么表示客户端已经被销毁。
*/
int processCommand(redisClient *c) {
/*
* 我在这里删了一些和本次分享无关的一些代码，让我们直接来到这里
* Handle the maxmemory directive.
*
* First we try to free some memory if possible (if there are volatile
* keys in the dataset). If there are not the only thing we can do
* is returning an error. */
// 如果设置了最大内存，那么检查内存是否超过限制，并做相应的操作
// 其中 maxmemory是我们在配置文件中可以设置的，在C语言中只要不等于0就是真
@1 if (server.maxmemory) {
// 如果内存已超过限制，那么尝试通过删除过期键来释放内存
int retval = freeMemoryIfNeeded();
// 如果即将要执行的命令可能占用大量内存（REDIS_CMD_DENYOOM）
// 并且前面的内存释放失败的话
// 那么向客户端返回内存错误
if ((c->cmd->flags & REDIS_CMD_DENYOOM) && retval == REDIS_ERR) {
flagTransaction(c);
addReply(c, shared.oomerr);
return REDIS_OK;
}
}
return REDIS_OK;
}
processCommand()这个函数在处理命令时在@1处如果说我们设置了maxmemory那么会调用freeMemoryIfNeeded()这个方法进行内存释放[也就是删除key的操作]，如果释放失败，返回错误。在我们没有分析freeMemoryIfNeeded()之前，如果让我们自己设计一个删除key的函数，想一想都有哪些步骤？我想无非是这样几个步骤：
1、计算目前已经使用了多少内存，需要释放多少内存？假设需要释放的内存为x。
2、遍历redis的每一个库，根据一定的策略【ANSWER2中的6个策略】找出要删除的key
3.删除key，释放内存，计算一下释放的内存是否已经大于等于步骤1中需要释放的内存x，如果达到这个条件本次删除key的任务结束【这里我觉得是考虑到服务性能的问题，想一想步骤1中不设置一个释放内存的阈值会出现什么问题？】。等分析完这个函数后，我会绘制一张流程图。我们现在只分析一种策略，那就是all-keys-lru这种内存淘汰策略
现在让我进入freeMemoryIfNeeded()这个重磅函数
int freeMemoryIfNeeded(void) {
/*
mem_used:已经使用的内存
mem_tofree：需要释放的内存
mem_freed:已经释放的内存
*/
size_t mem_used, mem_tofree, mem_freed;
int slaves = listLength(server.slaves);
/* Remove the size of slaves output buffers and AOF buffer from the
* count of used memory. */
// 计算出 Redis 目前占用的内存总数，但有两个方面的内存不会计算在内：
// 1）从服务器的输出缓冲区的内存
// 2）AOF 缓冲区的内存
mem_used = zmalloc_used_memory();
// @1 这部分计算内存的逻辑我们可以略过，无非就是 已经使用的内存-最大内存=需要释放的内存
if (slaves) {
listIter li;
listNode *ln;
listRewind(server.slaves,&li);
while((ln = listNext(&li))) {
redisClient *slave = listNodeValue(ln);
unsigned long obuf_bytes = getClientOutputBufferMemoryUsage(slave);
if (obuf_bytes > mem_used)
mem_used = 0;
else
mem_used -= obuf_bytes;
}
}
if (server.aof_state != REDIS_AOF_OFF) {
mem_used -= sdslen(server.aof_buf);
mem_used -= aofRewriteBufferSize();
}
/* Check if we are over the memory limit. */
// 如果目前使用的内存大小比设置的 maxmemory 要小，那么无须执行进一步操作
if (mem_used <= server.maxmemory) return REDIS_OK;
// 如果占用内存比 maxmemory 要大，但是 maxmemory 策略为不淘汰，那么直接返回
if (server.maxmemory_policy == REDIS_MAXMEMORY_NO_EVICTION)
return REDIS_ERR; /* We need to free memory, but policy forbids. */
/* Compute how much memory we need to free. */
// 计算需要释放多少字节的内存
mem_tofree = mem_used - server.maxmemory;
// 初始化已释放内存的字节数为 0
mem_freed = 0;
// 根据 maxmemory 策略，
// 遍历每个数据库，释放内存【删除key】并记录被释放内存的字节数
// @2已经释放的内存如果>=需要释放的内存 wilie循环终止，释放内存工作【惰性删key工作结束】
while (mem_freed < mem_tofree) {
int j, k, keys_freed = 0;
// @3 遍历所有数据库找出要删除的key，释放内存
for (j = 0; j < server.dbnum; j++) {
long bestval = 0; /* just to prevent warning */
sds bestkey = NULL; // 要删除的最合适的key
dictEntry *de;
redisDb *db = server.db+j; // 第j个数据库
dict *dict; // 数据库的词典，redis数据是键值对，存储在词典中
if (server.maxmemory_policy == REDIS_MAXMEMORY_ALLKEYS_LRU ||
server.maxmemory_policy == REDIS_MAXMEMORY_ALLKEYS_RANDOM)
{
// 如果策略是 allkeys-lru 或者 allkeys-random
// 那么淘汰的目标为所有数据库键
// @4 我们目前就是分析这个策略 all-keys-lru,所以词典就是第j个数据库中全部键值对
dict = server.db[j].dict;
} else {
// 如果策略是 volatile-lru 、 volatile-random 或者 volatile-ttl
// 那么淘汰的目标为带过期时间的数据库键
dict = server.db[j].expires;
}
// 跳过空字典，接着下一次for循环
if (dictSize(dict) == 0) continue;
/* volatile-random and allkeys-random policy */
// 如果使用的是随机策略，那么从目标字典中随机选出键，我们暂时略过个if
if (server.maxmemory_policy == REDIS_MAXMEMORY_ALLKEYS_RANDOM ||
server.maxmemory_policy == REDIS_MAXMEMORY_VOLATILE_RANDOM)
{
de = dictGetRandomKey(dict);
bestkey = dictGetKey(de);
}
/* volatile-lru and allkeys-lru policy */
// 如果使用的是 LRU 策略，
// @5 那么从一个sample 键中选出 IDLE 时间最长的那个键， 让我重点分析这个分支
else if (server.maxmemory_policy == REDIS_MAXMEMORY_ALLKEYS_LRU ||
server.maxmemory_policy == REDIS_MAXMEMORY_VOLATILE_LRU)
{
// @6 pool是一个数组，所有要删除的key按照idle time从小到大排序
// 这个数组在服务启动时进行初始化
struct evictionPoolEntry *pool = db->eviction_pool;
// @7 这个while循环就是要找出第j个数据库中要删除的最合适的key，也就是idle time
// 最长的那个key
while(bestkey == NULL) {
// @8 这个方法就是要找出词典中要删除的key，这些要删除的key
// 以idle time递增的方式保存在 eviction_pool
// 因为我们分析的是 all-keys-lru,它的 sampledict和dict是一样的，这里先不
// 详细解释解释这个函数，稍后我们再分析，只需要记住，他填充eviction_pool，里面是 //字典中需要删除的 key就行了
evictionPoolPopulate(dict, db->dict, db->eviction_pool);
/* Go backward from best to worst element to evict. */
for (k = REDIS_EVICTION_POOL_SIZE-1; k >= 0; k--) {
if (pool[k].key == NULL) continue;
de = dictFind(dict,pool[k].key);
/* Remove the entry from the pool. */
// 从数组中删除这个key
sdsfree(pool[k].key);
/* Shift all elements on its right to left. */
// 这个可以忽略，就是调整数组
memmove(pool+k,pool+k+1,
sizeof(pool[0])*(REDIS_EVICTION_POOL_SIZE-k-1));
/* Clear the element on the right which is empty
* since we shifted one position to the left. */
pool[REDIS_EVICTION_POOL_SIZE-1].key = NULL;
pool[REDIS_EVICTION_POOL_SIZE-1].idle = 0;
/* If the key exists, is our pick. Otherwise it is
* a ghost and we need to try the next element. */
if (de) {
// @9 返回指定节点的键，说明在第j个数据库中找到这个要删除的最合适的key了
bestkey = dictGetKey(de);
break;
} else {
/* Ghost... */
// 继续遍历
continue;
}
} // 遍历 pool数组的for循环结束
}// 找 第j个数据中最合适的key结束
/* Finally remove the selected key. */
// @10 这一步是真正的删除被选中的键
if (bestkey) {
long long delta;
robj *keyobj = createStringObject(bestkey,sdslen(bestkey));
// 忽略
propagateExpire(db,keyobj);
/* We compute the amount of memory freed by dbDelete() alone.
* It is possible that actually the memory needed to propagate
* the DEL in AOF and replication link is greater than the one
* we are freeing removing the key, but we can't account for
* that otherwise we would never exit the loop.
*
* AOF and Output buffer memory will be freed eventually so
* we only care about memory used by the key space. */
// 计算删除键所释放的内存数量
delta = (long long) zmalloc_used_memory();
dbDelete(db,keyobj);
delta -= (long long) zmalloc_used_memory();
mem_freed += delta;
// 对淘汰键的计数器增一
server.stat_evictedkeys++;
// 忽略
notifyKeyspaceEvent(REDIS_NOTIFY_EVICTED, "evicted",
keyobj, db->id);
decrRefCount(keyobj);
keys_freed++;
// 忽略
/* When the memory to free starts to be big enough, we may
* start spending so much time here that is impossible to
* deliver data to the slaves fast enough, so we force the
* transmission here inside the loop. */
if (slaves) flushSlavesOutputBuffers();
}
}
// 如果遍历完所有的数据库，删除key的个数为0，则返回错误，这个是快速失败
if (!keys_freed) return REDIS_ERR; /* nothing to free... */
} // end 最外层的while，删除key的工作结束
return REDIS_OK;
}
流程图如下：
至此我们分析完了freeMemoryIfNeeded（），还不算太复杂吧。在分析过程中我删掉了一些无用代码和分支。大家再比照着源码分析一下，相信很快就能掌握它。现在，我们总结下这个函数所做的事情是不是和我们开头所列举的吻合呢？我想应该吻合吧。在分析freeMemoryIfNeeded()这个函数的时候，大家是否还记得有一个pool数组用来盛放要删除的key，还有一个函数evictionPoolPopulate()用来填充pool数组。那它究竟是怎样计算的呢？我们在下篇文章接着进行分析。
总结
学好redis，并用好redis并非那么容易。有时候学习源码并非为了装逼，而是学习作者的思路和其优秀思想并能借鉴之。的确，学习源码能让我们对其内部实现了解一二，在平时看来神秘的东西，通过阅读源码感觉“也不过尔尔”。在信息轰炸和科技日新月异的今天，我们需要自己冷静，需要自己思考，需要自己有独特的判断力，我们不能被别人裹挟着前进，我们更不可能把所有计算机的技术都了如指掌，我们只需要有一方面技术的沉淀就行了，知识都是相似相通的。
标签：删除,REDIS,redis,源码,dict,惰性,key,pool,内存 来源： https://blog.csdn.net/dayday_up_good/article/details/118052904
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。