客户端属性
客户端的状态保存在结构体 redisClient 中，下面给出redisClient的部分属性：
typedef struct redisClient{ // 套接字描述符 int fd; // 客户端状态标志 int flags; // 输入缓冲区 sds querybuf; // 命令参数 robj** argv; int argc; // 命令的实现函数 struct redisCommand *cmd; // 固定输出缓冲区 char buf[REDIS_REPLY_CHUNK_BYTES]; int bufpos; // 可变大小输出缓冲区 list* reply; // ...... };
-
fd 属性：客户端使用的套接字描述符，伪客户端的fd属性为 -1，普通客户端的fd属性为大于0的整数。
-
flags 属性：客户端状态。在主从服务器复制时，主服务器和从服务器互为客户端，REDIS_MASTER 标志表示客户端代表的是一个主服务器，REDIS_SLAVE 标志表示客户端代表的是一个从服务器。
-
querybuf 属性：保存客户端发送的命令请求。
-
argv、argc 属性：对客户端的命令请求分析，得到的命令参数及命令参数的个数。
-
cmd 属性：服务器从客户端发送的命令请求中分析得到argv、argc参数后，会根据argv[0]的值，去查找该命令对应的实现函数，并使cmd指针指向该实现函数。
-
buf、bufpos 属性：bufpos属性记录了buf 数组已使用的字节数量。
-
reply 属性：当buf 数组空间不够用时，服务器会使用 reply 可变大小缓冲区。
命令请求
命令的执行过程
服务器在接收到命令后，会将命令以对象的形式保存在服务器client的参数列表 robj** argv 中，因此服务器执行命令请求时，服务器已经读入了一套命令参数保存在参数列表中。执行命令的过程对应的函数是processCommand()，部分源码如下：
int processCommand(redisClient *c) { // 查找命令，并进行命令合法性检查，以及命令参数个数检查 c->cmd = c->lastcmd = lookupCommand(c->argv[0]->ptr); if (!c->cmd) { // 没找到指定的命令 flagTransaction(c); addReplyErrorFormat(c,"unknown command '%s'", (char*)c->argv[0]->ptr); return REDIS_OK; } else if ((c->cmd->arity > 0 && c->cmd->arity != c->argc) || (c->argc < -c->cmd->arity)) { // 参数个数错误 flagTransaction(c); addReplyErrorFormat(c,"wrong number of arguments for '%s' command", c->cmd->name); return REDIS_OK; } // ...... /* Exec the command */ if (c->flags & REDIS_MULTI && c->cmd->proc != execCommand && c->cmd->proc != discardCommand && c->cmd->proc != multiCommand && c->cmd->proc != watchCommand) { // 在事务上下文中 // 除 EXEC 、 DISCARD 、 MULTI 和 WATCH 命令之外 // 其他所有命令都会被入队到事务队列中 queueMultiCommand(c); addReply(c,shared.queued); } else { // 执行命令 call(c,REDIS_CALL_FULL); c->woff = server.master_repl_offset; // 处理那些解除了阻塞的键 if (listLength(server.ready_keys)) handleClientsBlockedOnLists(); } return REDIS_OK; }
我们总结出执行命令的大致过程：
-
查找命令。对应的代码是：c->cmd = c->lastcmd = lookupCommand(c->argv[0]->ptr)
-
执行命令前的准备
-
执行命令。对应代码是：call(c,REDIS_CALL_FULL)
查找命令
lookupCommand 函数是对 dictFetchValue 函数的封装。dictFetchValue 函数会从 server.commands 字典中查找 name 命令。这个保存命令表的字典，键是命令的名称，值是命令表的地址。服务器初始化时会创建一张命令表。命令表部分代码如下：
struct redisCommand redisCommandTable[] = { {"get",getCommand,2,"r",0,NULL,1,1,1,0,0}, {"set",setCommand,-3,"wm",0,NULL,1,1,1,0,0}, {"setnx",setnxCommand,3,"wm",0,NULL,1,1,1,0,0}, // ...... };
执行命令
执行命令调用了call(c, CMD_CALL_FULL)函数，该函数是执行命令的核心。该函数其实是对 c->cmd->proc(c) 的封装， proc 指向命令的实现函数。
void call(redisClient *c, int flags) { // start 记录命令开始执行的时间 long long dirty, start, duration; // 记录命令开始执行前的 FLAG int client_old_flags = c->flags; // 如果可以的话，将命令发送到 MONITOR if (listLength(server.monitors) && !server.loading && !(c->cmd->flags & REDIS_CMD_SKIP_MONITOR)) { replicationFeedMonitors(c,server.monitors,c->db->id,c->argv,c->argc); } /* Call the command. */ c->flags &= ~(REDIS_FORCE_AOF|REDIS_FORCE_REPL); redisOpArrayInit(&server.also_propagate); // 保留旧 dirty 计数器值 dirty = server.dirty; // 计算命令开始执行的时间 start = ustime(); // 执行实现函数 c->cmd->proc(c); // 计算命令执行耗费的时间 duration = ustime()-start; // 计算命令执行之后的 dirty 值 dirty = server.dirty-dirty; // 不将从 Lua 中发出的命令放入 SLOWLOG ，也不进行统计 if (server.loading && c->flags & REDIS_LUA_CLIENT) flags &= ~(REDIS_CALL_SLOWLOG | REDIS_CALL_STATS); // 如果调用者是 Lua ，那么根据命令 FLAG 和客户端 FLAG // 打开传播（propagate)标志 if (c->flags & REDIS_LUA_CLIENT && server.lua_caller) { if (c->flags & REDIS_FORCE_REPL) server.lua_caller->flags |= REDIS_FORCE_REPL; if (c->flags & REDIS_FORCE_AOF) server.lua_caller->flags |= REDIS_FORCE_AOF; } // 如果有需要，将命令放到 SLOWLOG 里面 if (flags & REDIS_CALL_SLOWLOG && c->cmd->proc != execCommand) slowlogPushEntryIfNeeded(c->argv,c->argc,duration); // 更新命令的统计信息 if (flags & REDIS_CALL_STATS) { c->cmd->microseconds += duration; c->cmd->calls++; } // 将命令复制到 AOF 和 slave 节点 if (flags & REDIS_CALL_PROPAGATE) { int flags = REDIS_PROPAGATE_NONE; // 强制 REPL 传播 if (c->flags & REDIS_FORCE_REPL) flags |= REDIS_PROPAGATE_REPL; // 强制 AOF 传播 if (c->flags & REDIS_FORCE_AOF) flags |= REDIS_PROPAGATE_AOF; // 如果数据库有被修改，那么启用 REPL 和 AOF 传播 if (dirty) flags |= (REDIS_PROPAGATE_REPL | REDIS_PROPAGATE_AOF); if (flags != REDIS_PROPAGATE_NONE) propagate(c->cmd,c->db->id,c->argv,c->argc,flags); } // 将客户端的 FLAG 恢复到命令执行之前 // 因为 call 可能会递归执行 c->flags &= ~(REDIS_FORCE_AOF|REDIS_FORCE_REPL); c->flags |= client_old_flags & (REDIS_FORCE_AOF|REDIS_FORCE_REPL); // 传播额外的命令 if (server.also_propagate.numops) { int j; redisOp *rop; for (j = 0; j < server.also_propagate.numops; j++) { rop = &server.also_propagate.ops[j]; propagate(rop->cmd, rop->dbid, rop->argv, rop->argc, rop->target); } redisOpArrayFree(&server.also_propagate); } server.stat_numcommands++; }
执行命令 c->cmd->proc(c) 就相当于执行了命令实现的函数，然后会在执行完成后，由这些函数产生相应的命令回复，根据回复的大小，会将回复保存在输出缓冲区 buf 或可变输出缓冲区链表 reply 中。
maxmemory策略
Redis 服务器对内存使用会有一个server.maxmemory的限制，如果超过这个限制，就要通过删除一些键空间来释放一些内存，具体函数对应freeMemoryIfNeeded()。释放内存时，可以指定不同的策略。策略保存在maxmemory_policy中，可以指定以下的几个值：
#define MAXMEMORY_VOLATILE_LRU 0 #define MAXMEMORY_VOLATILE_TTL 1 #define MAXMEMORY_VOLATILE_RANDOM 2 #define MAXMEMORY_ALLKEYS_LRU 3 #define MAXMEMORY_ALLKEYS_RANDOM 4 #define MAXMEMORY_NO_EVICTION 5
可以看出主要分为三种：
- LRU：优先删除最近最少使用的键。
- TTL：优先删除生存时间最短的键。
- RANDOM：随机删除。
而ALLKEYS和VOLATILE的不同之处就是要确定是从数据库的键值对字典还是过期键字典中删除。
int freeMemoryIfNeeded(void) { size_t mem_used, mem_tofree, mem_freed; int slaves = listLength(server.slaves); // 计算出 Redis 目前占用的内存总数，但有两个方面的内存不会计算在内： // 1）从服务器的输出缓冲区的内存 // 2）AOF 缓冲区的内存 mem_used = zmalloc_used_memory(); 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(); } // 如果目前使用的内存大小比设置的 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. */ // 计算需要释放多少字节的内存 mem_tofree = mem_used - server.maxmemory; // 初始化已释放内存的字节数为 0 mem_freed = 0; // 根据 maxmemory 策略， // 遍历字典，释放内存并记录被释放内存的字节数 while (mem_freed < mem_tofree) { int j, k, keys_freed = 0; // 遍历所有字典 for (j = 0; j < server.dbnum; j++) { long bestval = 0; /* just to prevent warning */ sds bestkey = NULL; dictEntry *de; redisDb *db = server.db+j; dict *dict; if (server.maxmemory_policy == REDIS_MAXMEMORY_ALLKEYS_LRU || server.maxmemory_policy == REDIS_MAXMEMORY_ALLKEYS_RANDOM) { // 如果策略是 allkeys-lru 或者 allkeys-random // 那么淘汰的目标为所有数据库键 dict = server.db[j].dict; } else { // 如果策略是 volatile-lru 、 volatile-random 或者 volatile-ttl // 那么淘汰的目标为带过期时间的数据库键 dict = server.db[j].expires; } // 跳过空字典 if (dictSize(dict) == 0) continue; /* volatile-random and allkeys-random policy */ // 如果使用的是随机策略，那么从目标字典中随机选出键 if (server.maxmemory_policy == REDIS_MAXMEMORY_ALLKEYS_RANDOM || server.maxmemory_policy == REDIS_MAXMEMORY_VOLATILE_RANDOM) { de = dictGetRandomKey(dict); bestkey = dictGetKey(de); } // 如果使用的是 LRU 策略， // 那么从一集 sample 键中选出 IDLE 时间最长的那个键 else if (server.maxmemory_policy == REDIS_MAXMEMORY_ALLKEYS_LRU || server.maxmemory_policy == REDIS_MAXMEMORY_VOLATILE_LRU) { struct evictionPoolEntry *pool = db->eviction_pool; while(bestkey == NULL) { 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. */ 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) { bestkey = dictGetKey(de); break; } else { /* Ghost... */ continue; } } } } // 策略为 volatile-ttl ，从一集 sample 键中选出过期时间距离当前时间最接近的键 else if (server.maxmemory_policy == REDIS_MAXMEMORY_VOLATILE_TTL) { for (k = 0; k < server.maxmemory_samples; k++) { sds thiskey; long thisval; de = dictGetRandomKey(dict); thiskey = dictGetKey(de); thisval = (long) dictGetVal(de); /* Expire sooner (minor expire unix timestamp) is better * candidate for deletion */ if (bestkey == NULL || thisval < bestval) { bestkey = thiskey; bestval = thisval; } } } // 删除被选中的键 if (bestkey) { long long delta; robj *keyobj = createStringObject(bestkey,sdslen(bestkey)); propagateExpire(db,keyobj); // 计算删除键所释放的内存数量 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++; if (slaves) flushSlavesOutputBuffers(); } } if (!keys_freed) return REDIS_ERR; /* nothing to free... */ } return REDIS_OK; }