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;// ......
};

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;
}

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},// ......
};

void call(redisClient *c, int flags) {// start 记录命令开始执行的时间long long dirty, start, duration;// 记录命令开始执行前的 FLAGint client_old_flags = c->flags;
// 如果可以的话，将命令发送到 MONITORif (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++;
}

#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

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;elsemem_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;// 初始化已释放内存的字节数为 0mem_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;
}