redis淘汰策略的几种实现

int freeMemoryIfNeeded(void) {
    /**
     * noeviction 不淘汰数据，什么都不做
     */
    if (server.maxmemory_policy == MAXMEMORY_NO_EVICTION)
        return C_ERR;
    while (mem_freed < mem_tofree) {
        int j, k, keys_freed = 0;
        for (j = 0; j < server.dbnum; j++) {
            /**
             * 选择操作的哈希表，Redis另外维护着一个保存过期时间的key=>expire关联的哈希表
             */
            if (server.maxmemory_policy == MAXMEMORY_ALLKEYS_LRU ||
                server.maxmemory_policy == MAXMEMORY_ALLKEYS_RANDOM)
            {
                dict = server.db[j].dict;
            } else {
                dict = server.db[j].expires;
            }
            /**
             * 分支一：全局哈希表随机或者过期时间哈希表中，随机淘汰一个key
             */
            if (server.maxmemory_policy == MAXMEMORY_ALLKEYS_RANDOM ||
                server.maxmemory_policy == MAXMEMORY_VOLATILE_RANDOM)
            {
                de = dictGetRandomKey(dict);
                bestkey = dictGetKey(de);
            }
            /**
             * 分支二：全局哈希表随机或者过期时间哈希表中，随机采样多个数据，再运用lru算法挑选一个淘汰
             */
            else if (server.maxmemory_policy == MAXMEMORY_ALLKEYS_LRU ||
                server.maxmemory_policy == MAXMEMORY_VOLATILE_LRU)
            {
                /* 样本集 */
                struct evictionPoolEntry *pool = db->eviction_pool;
                while(bestkey == NULL) {
                    /* 
                     * 采样，更新和维护样本集；
                     * 样本集开始是空的，每次操作完并不会清空样本集；
                     * 而且每次采样，都会采集多个数据，同时和样本集中已有的数据进行比较，新增或者更新样本集；
                     */ 
                    evictionPoolPopulate(dict, db->dict, db->eviction_pool);
                    /**
                     * 开始对样本集使用lru算法，淘汰样本集中访问时间最晚的key
                     */
                    for (k = MAXMEMORY_EVICTION_POOL_SIZE-1; k >= 0; k--) {
                        if (pool[k].key == NULL) continue;
                        de = dictFind(dict,pool[k].key);
                        /* 把选取到的key从样本集中移除 */
                        sdsfree(pool[k].key);
                        memmove(pool+k,pool+k+1,
                            sizeof(pool[0])*(MAXMEMORY_EVICTION_POOL_SIZE-k-1));
                        pool[MAXMEMORY_EVICTION_POOL_SIZE-1].key = NULL;
                        pool[MAXMEMORY_EVICTION_POOL_SIZE-1].idle = 0;
                        /* pool样本集内的key，只是样本，不一定和db内保持一致，也不必，可能在db中已经被删除的，所以要作判断 */
                        if (de) {
                            bestkey = dictGetKey(de);
                            break;
                        } else {
                            /* Ghost... */
                            continue;
                        }
                    }
                }
            }
            /**
             * 分支三：在设置了过期时间的哈希表里面随机选择多个key，在挑选到的key中选择过期时间最小的一个淘汰掉
             */
            else if (server.maxmemory_policy == 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);
                    if (bestkey == NULL || thisval < bestval) {
                        bestkey = thiskey;
                        bestval = thisval;
                    }
                }
            }
            if (bestkey) {
                long long delta;
                robj *keyobj = createStringObject(bestkey,sdslen(bestkey));
                // 命令扩散，把删除key的命令同步到所有从库slave
                propagateExpire(db,keyobj);
                // 删除key
                dbDelete(db,keyobj);
            }
        }
    }
    return C_OK;
}