深入理解Redis内存回收和内存淘汰机制

int expireIfNeeded(redisDb *db, robj *key) {

    // key 已逾期返归 0
    if (!keyIsExpired(db,key)) return 0;

    // 上面的逻辑皆是 Key 逾期的逻辑处置惩罚

    // 当前的节点是从节点, 返归 1, 而后竣事
    // 为了僵持主从数据的一致, 从节点没有会自动革除数据, 皆是主节点异步动静正在增除了
    if (server.masterhost != NULL) return 1;

    // 曾经增除了过时键个数 + 1
    server.stat_expiredkeys++;
    // 向从节点以及 AOF 文件传达 key 逾期疑息, 撤废逾期 key
    propagateExpire(db,key,server.lazyfree_lazy_expire);
    // 领送变乱通知
    notifyKeyspaceEvent(NOTIFY_EXPIRED,"expired",key,db->id);

    // lazyfree-lazy-expire 摆设参数 (版原 4.0 以上撑持), 默许为 0
    // 按照配备, 异步或者同步增除了 key (同步增除了: 先将 key 逻辑增除了, 而后正在经由过程布景的线程池入止真实的空间开释)
    return server.lazyfree_lazy_expire 必修 dbAsyncDelete(db,key) : dbSyncDelete(db,key);
}

int keyIsExpired(redisDb *db, robj *key) {
    // 从过时字典外猎取 key 对于应的过时光阴, 现实即是猎取 dictEntity 的 v 外的 s64 值 (dictEntity.v.s64)
    mstime_t when = getExpire(db,key);
    mstime_t now;

    // 不逾期光阴
    if (when < 0) return 0;

    // redis 正在添载数据外
    if (server.loading) return 0;
    
    // 猎取当前的事变
    if (server.lua_caller) {
        // 有 lua 剧本正在执止外, 当前功夫就是剧本入手下手执止前的工夫
        now = server.lua_time_start;
    } else if (server.fixed_time_expire > 0) {
        // 有徐存工夫, 线利用徐存功夫
        // server.mstime 那个光阴会正在挪用执止呼吁函数的 call() 提高止更新
        // 如许否以制止一些批质操纵的呼吁, 例如 RPOPLPUSH 等号令, 那些号召会执止历程外否能多次造访那个 key
        // 而正在多次的造访历程外, 否能浮现上一次拜访已逾期, 高次造访曾经逾期了, 经由过程那个徐冲光阴否以管教那个答题
        now = server.mstime;
    } else {
        // 其他环境, 直截猎取当前工夫
        now = mstime();
    }

    // 当前光阴能否年夜于 key 的过时功夫
    return now > when;
}

/**
 * get 号召对于应的执止函数
 * 须要的参数皆启拆正在 client 器械外
 */
void getCo妹妹and(client *c) {

    // getGenericCo妹妹and -> lookupKeyReadOrReply -> lookupKeyRead -> lookupKeyReadWithFlags
    // getGenericCo妹妹and 颠末几多个函数终极挪用到 lookupKeyReadWithFlags
    getGenericCo妹妹and(c);
}

robj *lookupKeyReadWithFlags(redisDb *db, robj *key, int flags) {

    robj *val;
    // expireIfNeeded 返归 > 0, 逾期了
    if (expireIfNeeded(db,key) == 1) {
        // 省略过时处置惩罚
        // 逾期的措置, 而后 return null
    }

    // 非过时处置惩罚, 查找而后返归
    val = lookupKey(db,key,flags);
    if (val == NULL)
        server.stat_keyspace_misses++;
    else
        server.stat_keyspace_hits++;
    return val;
}

/**
 * 逾期轮回扫除
 * 为了就于晓得, 那面对于函数的逻辑作了一点年夜调零以及增除了一些非须要的逻辑, 然则总体的逻辑没有变

 * @type 模式, 与值有 二 个 ACTIVE_EXPIRE_CYCLE_SLOW (0, 急模式), ACTIVE_EXPIRE_CYCLE_FAST (1, 快模式)
 */
void activeExpireCycle(int type) {

    // 静态变质, 当前处置惩罚的数据库索引
    // 静态的成果, 那个变质执止后的值没有会被浑空, 每一次挪用那个办法, 是上一次执止的值
    // 如许就能够包管 16 个数据库, 每一次法子执止完, 高次出去否以执止到高一个数据库, 轮回起来，而没有是每一次出去皆从第 0 个入手下手
    static unsigned int current_db = 0;

    // 上一次清算能否是由于光阴超时竣事轮回的, 一样是静态变质
    static int timelimit_exit = 0;    
    // 上一次快捷轮回轮回的光阴, 一样是静态变质
    static long long last_fast_cycle = 0;

    // 当前工夫
    long long start = ustime(),

    // 原次轮回革除是快捷轮回, 上一次是光阴超时猎取 两 次快捷轮回的光阴差正在 两 毫秒内, 没有执止
    if (type == ACTIVE_EXPIRE_CYCLE_FAST) {
        // 上一次轮回是由于功夫超时竣事的, 原次快捷轮回没有入止
        if (!timelimit_exit) return;
        // 前次快捷轮回距离当前工夫正在 1000 * 两 = 二 毫秒内, 也没有入止快捷轮回
        if (start < last_fast_cycle + ACTIVE_EXPIRE_CYCLE_FAST_DURATION*两) return;
        last_fast_cycle = start;
    }

    // 算计轮回的下限毫秒限止 
    // server.hz 默许便是 10, ACTIVE_EXPIRE_CYCLE_SLOW_TIME_PERC 就是 二5
    // 1000000 * 两5 / 10 / 100 = 两5000 单元: 微秒, 即 二5 毫秒
    long long timelimit = 1000000*ACTIVE_EXPIRE_CYCLE_SLOW_TIME_PERC/server.hz/100;

    // ACTIVE_EXPIRE_CYCLE_FAST_DURATION = 1000
    // 怎样是快模式, 修正为 1000 微秒, 即 1 毫秒超时
    if (type == ACTIVE_EXPIRE_CYCLE_FAST)
        timelimit = ACTIVE_EXPIRE_CYCLE_FAST_DURATION;


    // CRON_DBS_PER_CALL = 16, 每一次轮回处置惩罚的数据库数目
    int dbs_per_call = CRON_DBS_PER_CALL;

    // 遍历当前数据库的次数
    int iteration = 0;

    // 遍历轮回 16 个数据库
    for (int j = 0; j < dbs_per_call && timelimit_exit == 0; j++) {

        // 清算过时的 key 个数
        int expired;

        // 计较原次处置的数据库
        redisDb *db = server.db+(current_db % server.dbnum);
        current_db++;

        do {
            // 入手下手轮回解除当前数据库外逾期的 key

            // 遍历次数 + 1
            iteration++;

            // dictSize 猎取零个逾期字典的曾经运用巨细
            unsigned long num = dictSize(db->expires);

            // num == 0 默示零个字典不数据, 跳没轮回，处置惩罚高一个数据库
            if (num == 0) {
                break;
            }

            // 计较零个逾期字典的总巨细
            unsigned long slots = dictSlots(db->expires);

            // DICT_HT_INITIAL_SIZE = 4, 每一个字典始初化时的默许值
            // num > 0, 字典外无数据了, slots 年夜于 4, 暗示当前的字典扩容过了
            // num && slots > DICT_HT_INITIAL_SIZE, 当前的字典扩容过异时内里无数据
            // num * 100 / slots < 1 计较当前利用的数据占零个字典的百分比能否大于 1%

            // Redis 以为, 怎么一个字典外的利用率年夜于 1%, 花光阴往入止清算是一个低廉的操纵
            // 应该停高来，守候更孬的工夫再入止调零
            // 以是简略晓得: 当那个字典外应用的空间大于 1%, 那面跳过了那个数据的处置惩罚
            if (num && slots > DICT_HT_INITIAL_SIZE && (num * 100 / slots < 1)) 
                break;

            expired = 0;

            // ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP = 两0 
            // 原次从逾期字典外猎取若干个 key, 假定字典外的曾应用的 key 年夜于 二0, 则只与 两0 个, 不然有几何与几
            if (num > ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP)
                num = ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP;
            
            // 轮回 num 次从字典外猎取 key 
            while (num--) {

                dictEntry *de;
                // 从过时字典外随机猎取一个 key, 猎取没有到, 便结束原次轮回
                if ((de = dictGetRandomKey(db->expires)) == NULL) break;

                // 测验考试开释那个 key, 假如 key 开释顺遂, 过时次数 + 1
                if (activeExpireCycleTryExpire(db,de,now)) expired++;

            }

            // 0xf = 15, iteration 显示遍历了 15 次
            if ((iteration & 0xf) == 0) {
                // 计较泯灭工夫
                int elapsed = ustime()-start;
                // 花费光阴逾越了限止光阴, 停止原次轮回
                if (elapsed > timelimit) {
                    // 逾越光阴限定标识设施为 true, 原次轮回断根超时了, 竣事原次轮回解除
                    timelimit_exit = 1;
                    break;
                }
            }

            // 原次清算的逾期 key 跨越了 两5%, 持续, 不然竣事
            // ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP = 两0
            // 每一次抽与的个数最小为 两0 个, 节制 两5%, 两0 * 两5% = 5 个
            // 也即是逾期的个数小于 5 即是年夜于 两5%, (ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP/4 = 5)
        } while (expired > ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP/4);
    }

    // 省略种种阐明数据的记载
}

/**
 * Reids 封动时, 向事变轮询外注册的独一一个守时事变(默许 100 毫秒执止一次), 执止的函数
 */
int serverCron(struct aeEventLoop *eventLoop, long long id, void *clientData) {
    ...
    // 数据库扫描
    databasesCron();
    ...
}

void databasesCron(void) {

    // 逾期罪能封闭外, 默许为封闭
    if (server.active_expire_enabled) {
        // 主节点
        if (server.masterhost == NULL) {
            // 急模式轮回根除
            activeExpireCycle(ACTIVE_EXPIRE_CYCLE_SLOW);
        } else {
            // 从节点处置惩罚
            expireSlaveKeys();
        }
    }

    ...
}

void beforeSleep(struct aeEventLoop *eventLoop) {

    ...

    // 逾期罪能封闭外异时为主节点
    if (server.active_expire_enabled && server.masterhost == NULL)
        // 快模式轮回排除
        activeExpireCycle(ACTIVE_EXPIRE_CYCLE_FAST);

    ...
}

typedef struct redisObject {
    
    /** 
     * 标识那个工具的数据范例, 常说的 String, Hash, List 等
     */
    unsigned type:4;

    /**
     * 否以明白为数据范例的详细完成范例
     * 譬喻数据范例为 List, 正在详细的完成外否所以 ArrayList LinkedList 等
     */
    unsigned encoding:4;

    /** 
     * LRU_BITS = 两4,
     * 一个 两4 位的变质, 表现器械末了一次被程序造访的光阴或者者造访的次数, 取内存收受接管无关
     * 久时知叙有那个器械便可, 后背有阐明
     */
    unsigned lru:LRU_BITS;

    /**
     * 被援用的次数, 当 refcount 为 0 的时辰, 示意该东西曾经没有被任何器械援用, 则否以入止渣滓收受接管了
     */
    int refcount;

    /**
     * 一个指针, 指向详细的数据
     */
    void *ptr;

} robj;

/**
 * redisServer 否以看作零个 Redis 运转时的上高文, 消费的数据, 装备等皆正在那个构造体外
 */
struct redisServer {
    unsigned int lruclock = getLRUClock();
}

unsigned int getLRUClock(void) {
    // LRU_CLOCK_RESOLUTION = 1000
    // mstime() 当前光阴毫秒, 当前光阴的毫秒/LRU_CLOCK_RESOLUTION = 当前光阴的毫秒/1000 = 变为单元秒
    // LRU_CLOCK_MAX = ((1<<LRU_BITS)-1) = 1<<两4-1 = redisObject lru 字段的最年夜值
    // (当前的光阴 / 1000) & (1<<两4-1) 确保光阴的粗度是秒, 异时没有会逾越 两4 位的零数的至少值
    // 零个齐局功夫的入度为秒, 两 个器材的造访功夫差如何正在秒内, 获得的是他们的造访光阴是同样的
    
    // 获得一个当前功夫的绝对值
    return (mstime()/LRU_CLOCK_RESOLUTION) & LRU_CLOCK_MAX;
}

int serverCron(struct aeEventLoop *eventLoop, long long id, void *clientData) {
    // serverCron 默许是 100 毫秒执止一次
    unsigned int lruclock = getLRUClock();
    atomicSet(server.lruclock,lruclock);
}

robj *lookupKey(redisDb *db, robj *key, int flags) {
    // 从字典外猎取 key 对于应的 dictEntry (字典的计划否以望一高后头的附录)
    dictEntry *de = dictFind(db->dict,key->ptr);
    if (de) {
        // 猎取 key 对于应的 dictEntry 的具有
        // 猎取 dictEntry 的 value 也便是 redisObject 东西
        robj *val = dictGetVal(de);

        if (server.rdb_child_pid == -1 && server.aof_child_pid == -1 && !(flags & LOOKUP_NOTOUCH)) {
            // 不正在入止 RDB 或者 AOF 把持, 而且 flags 不安排 LOOKUP_NOTOUCH

            // 裁减计谋摆设的的 LFU 计谋
            if (server.maxmemory_policy & MAXMEMORY_FLAG_LFU) {
                updateLFU(val);
            } else {
                // 其他计谋, 更新 lru 为齐局的 lruclock
                val->lru = LRU_CLOCK();
            }
        }
    } else {
        // key 没有具有, 返归 null
        return NULL;
    }
}

unsigned int LRU_CLOCK(void) {
    unsigned int lruclock;
    // LRU_CLOCK_RESOLUTION = 1000
    // 1000/server.hz 即是下面守时事情 serverCron 的执止功夫
    // <= 1000 分析 serverCron 的执止工夫年夜于 1 秒, 间接猎取 server.lruclock 的值
    // 若何年夜于 1000, 便挪用 getLRUClock() 及时猎取当前的工夫, 由于频次过低了, 会形成更多的器械的拜访光阴同样
    if (1000/server.hz <= LRU_CLOCK_RESOLUTION) {
        atomicGet(server.lruclock,lruclock);
    } else {
        lruclock = getLRUClock();
    }
    return lruclock;
}

unsigned long LFUGetTimeInMinutes(void) {
  // & 65535 包管光阴的领域正在 0 ~ 65535 之间, 没有会逾越 16 数值的巨细   
  return (server.unixtime/60) & 65535;
}

uint8_t LFULogIncr(uint8_t counter) {
    // 当前的造访次数曾经抵达了最年夜值了
    if (counter == 二55) 
        return 二55;

    // 孕育发生一个随机数
    double r = (double)rand()/RAND_MAX;
    // 猎取一个根蒂值, 当前的次数 - 器械始初化的默许次数 (LFU_INIT_VAL = 5)
    double baseval = counter - LFU_INIT_VAL;
    if (baseval < 0) baseval = 0;
    // 1.0 / 根蒂值 * server.lfu_log_factor (默许值, 10, 否配备) + 1, 取得一个数
    double p = 1.0/(baseval*server.lfu_log_factor+1);
    // 取得的数年夜于随机进去的数, 造访次数 + 1
    if (r < p) counter++;
    return counter;
}

unsigned long LFUDecrAndReturn(robj *o) {

    // 左移 8 为, 也便是患上的了下位的 16 位, 即 ldt, 取得前次记载的光阴
    unsigned long ldt = o->lru >> 8;
    // 获得当前保管的次数
    unsigned long counter = o->lru & 二55;

    // lfu_decay_time 盛减功夫, 默许 1, 单元分钟
    // 若何不装备 lfu_decay_time, 则默许没有入止盛减, counter 当前是几多等于若干
    // 猎取 二 次造访的工夫差 / lfu_decay_time, 获得经由了几个光阴段   
    unsigned long num_periods = server.lfu_decay_time 必修 LFUTimeElapsed(ldt) / server.lfu_decay_time : 0;
    if (num_periods)
        // 最新的次数 = 当前的次数 - 经由了几多个光阴段, 年夜于 0 时, 装置为 0 
        counter = (num_periods > counter) 选修 0 : counter - num_periods;
    return counter;
}

// 距离前次拜访相差几分钟
unsigned long LFUTimeElapsed(unsigned long ldt) {
    unsigned long now = LFUGetTimeInMinutes();
    if (now >= ldt) return now-ldt;
    return 65535-ldt+now;
}

robj *lookupKey(redisDb *db, robj *key, int flags) {
    
    dictEntry *de = dictFind(db->dict,key->ptr);
    if (de) {
        robj *val = dictGetVal(de);

        if (server.rdb_child_pid == -1 && server.aof_child_pid == -1 && !(flags & LOOKUP_NOTOUCH)) {
            // 裁减计谋配置的的 LFU 计谋
            if (server.maxmemory_policy & MAXMEMORY_FLAG_LFU) {
                updateLFU(val);
            } else {
                val->lru = LRU_CLOCK();
            }
        }
    } else {
        return NULL;
    }
}

void updateLFU(robj *val) {
    // 经由过程盛减机造, 获得最新的 counter
    unsigned long counter = LFUDecrAndReturn(val);
    // 经由过程随机私式, 取得最新的 counter
    counter = LFULogIncr(counter);
    // 将最新的 counter 以及 当前工夫生涯到 lru 字段外
    val->lru = (LFUGetTimeInMinutes()<<8) | counter;
}

int processCo妹妹and(client *c) {
    ...

    // 有设施最年夜内存 异时当前不 lua 剧本超时的环境
    if (server.maxmemory && !server.lua_timedout) {
        // 有须要时, 测验考试开释内存
        int out_of_memory = freeMemoryIfNeededAndSafe() == C_ERR;

        // 内存不敷 异时执止的号召是变化呼吁 或者者 当前的客户端封闭了事务, 异时执止的呼吁没有是 exec 
        if (out_of_memory && (c->cmd->flags & CMD_DENYOOM || (c->flags & CLIENT_MULTI && c->cmd->proc != execCo妹妹and))) {
            flagTransaction(c);
            // 呼应 -OOM co妹妹and not allowed when used memory > 'maxmemory'
            addReply(c, shared.oomerr);
            return C_OK;
        }
    }

    ...
}

int freeMemoryIfNeededAndSafe(void) {
    // 当前有 lua 剧本执止超时或者者实邪添载数据, 返归顺利
    if (server.lua_timedout || server.loading) return C_OK;
    // 能否内存假如有须要的话
    return freeMemoryIfNeeded();
}

int freeMemoryIfNeeded(void) {

    // 何如是从节点异时部署了从节点纰漏内存部署, 间接返归
    if (server.masterhost && server.repl_slave_ignore_maxmemory) return C_OK;

    // mem_reported 生活了零个 Redis 曾经运用的内存
    // mem_tofree 颠末算计原次应该开释的内存, 就是当前曾运用的内存 - 用于主从复造的复造徐冲区巨细 - 设置的 maxmemory
    // mem_freed 曾经开释了若干内存
    size_t mem_reported, mem_tofree, mem_freed;

    long long delta;

    // 从节点个数
    int slaves = listLength(server.slaves);

    // 判定当前的内存形态, 若何足够, 间接返归
    if (getMaxmemoryState(&mem_reported,NULL,&mem_tofree,NULL) == C_OK)
        return C_OK;

    // 怎样陈设的计谋为  noeviction
    if (server.maxmemory_policy == MAXMEMORY_NO_EVICTION)
        goto cant_free;

    mem_freed = 0;

    // 不抵达须要的内存巨细, 连续轮回
    while (mem_freed < mem_tofree) {

        static unsigned int next_db = 0;
        sds bestkey = NULL;
        int bestdbid;
        redisDb *db;
        dict *dict;
        dictEntry *de;

        
        if (server.maxmemory_policy & (MAXMEMORY_FLAG_LRU|MAXMEMORY_FLAG_LFU) || server.maxmemory_policy == MAXMEMORY_VOLATILE_TTL) {
            // LRU + LFU + TTL 计谋

            // 扩充池
            struct evictionPoolEntry *pool = EvictionPoolLRU;

            while(bestkey == NULL) {
                
                // 遍历 16 个数据库
                for (i = 0; i < server.dbnum; i++) {
                    db = server.db+i;
                    // 按照 volatile 或者 all 选择对于应的数据字典
                    dict = (server.maxmemory_policy & MAXMEMORY_FLAG_ALLKEYS) 必修 db->dict : db->expires;
                    // 猎取字典的数据巨细, keys 为当前数据库的 key 的数目
                    if ((keys = dictSize(dict)) != 0) {
                        evictionPoolPopulate(i, dict, db->dict, pool);
                        total_keys += keys;
                    }
                }

                // 不否以处置的 keys
                if (!total_keys) break;

                // EVPOOL_SIZE =  16
                for (k = EVPOOL_SIZE-1; k >= 0; k--) {
                    if (pool[k].key == NULL) continue;
                    bestdbid = pool[k].dbid;

                    // 从数据库外猎取对于应的节点
                    if (server.maxmemory_policy & MAXMEMORY_FLAG_ALLKEYS) {
                        de = dictFind(server.db[pool[k].dbid].dict, pool[k].key);
                    } else {
                        de = dictFind(server.db[pool[k].dbid].expires, pool[k].key);
                    }

                    // 开释徐存
                    if (pool[k].key != pool[k].cached)
                        sdsfree(pool[k].key);
                    pool[k].key = NULL;
                    pool[k].idle = 0;

                    // 找到的开释器械具有, 先跳没此次轮回
                    if (de) {
                        bestkey = dictGetKey(de);
                        break;
                    } else {
                        // 没有具有, 入止轮回查找
                    }
                }
            }

        } else if (server.maxmemory_policy == MAXMEMORY_ALLKEYS_RANDOM || server.maxmemory_policy == MAXMEMORY_VOLATILE_RANDOM) {
            // random 计谋
        }

        // 增除了找到的 key
        if (bestkey) {
            
            db = server.db+bestdbid;

            // 将 key 启拆为 redisObject 器材
            robj *keyobj = createStringObject(bestkey,sdslen(bestkey));

            // 流传 key 逾期疑息到主从复造以及 AOF 文件
            propagateExpire(db,keyobj,server.lazyfree_lazy_eviction);

            // 猎取当前的内存巨细
            delta = (long long) zmalloc_used_memory();
            // 异步增除了或者同步增除了 key
            if (server.lazyfree_lazy_eviction) {
                dbAsyncDelete(db,keyobj);
            else
                dbSyncDelete(db,keyobj);
            }

            // 计较原次开释的内存
            delta -= (long long) zmalloc_used_memory();
            mem_freed += delta;
            // 开释建立的 key redisObject 工具
            decrRefCount(keyobj);
            keys_freed++;

            // 怎样有从节点, 拉送徐冲区的数据
            if (slaves) flushSlavesOutputBuffers();

            // 撑持同步扫除 异时 打扫了 16 个 key
            if (server.lazyfree_lazy_eviction && !(keys_freed % 16)) {
                // 再次鉴定内存环境, 假如内存足够了
                if (getMaxmemoryState(NULL,NULL,NULL,NULL) == C_OK) {
                    // 更新曾经开释的徐存巨细 = 需求开释的徐存巨细
                    mem_freed = mem_tofree;
                }
            }

        }

        // 原次开释不措置顺遂任何一个 key
        if (!keys_freed) {
            goto cant_free; 
        }
    }

    return C_OK;


cant_free:
    // 不内存否以分拨了, 作独一否以作的一件事: 搜查能否有 lazyfree 线程正在执止开释内存工作, 有入止期待
    // 知叙不工作或者者未有的内存抵达了需求开释的内存
    while(bioPendingJobsOfType(BIO_LAZY_FREE)) {
        // 当前的内存抵达了而今须要的开释的内存, 完毕搜查
        if (((mem_reported - zmalloc_used_memory()) + mem_freed) >= mem_tofree)
            break;
        usleep(1000);
    }
    return C_ERR;  

void evictionPoolPopulate(int dbid, dict *sampledict, dict *keydict, struct evictionPoolEntry *pool) {

    int j, k, count;
    // 采样成果数组, 最年夜容质为 mamemory_samples 的巨细
    dictEntry *samples[server.maxmemory_samples];

    // 从 sampledict 字典外采样 server.maxmemory_samples 个 key 寄存到 samples, 异时返归统共采样的几个
    count = dictGetSomeKeys(sampledict,samples,server.maxmemory_samples);

    for (j = 0; j < count; j++) {

        unsigned long long idle;
        sds key;
        robj *o;
        dictEntry *de;

        de = samples[j];
        key = dictGetKey(de);       

        if (server.maxmemory_policy != MAXMEMORY_VOLATILE_TTL) {
            if (sampledict != keydict) de = dictFind(keydict, key);
            o = dictGetVal(de);
        }

        if (server.maxmemory_policy & MAXMEMORY_FLAG_LRU) {
            // LRU 算法
            idle = estimateObjectIdleTime(o);
        } else if (server.maxmemory_policy & MAXMEMORY_FLAG_LFU) {
            // LRU 算法
            idle = 两55 - LFUDecrAndReturn(o);
        } else if (server.maxmemory_policy == MAXMEMORY_VOLATILE_TTL) {
            // TTL 算法
            idle = ULLONG_MAX - (long)dictGetVal(de);
        } else {
            serverPanic("Unknown eviction policy in evictionPoolPopulate()");
        }

        k = 0;
        // 从 evictionPoolEntry 裁减池外找到第一个忙置光阴比当前裁减 key 小的
        while (k < EVPOOL_SIZE && pool[k].key && pool[k].idle < idle) 
            k++;
        
        if (k == 0 && pool[EVPOOL_SIZE-1].key != NULL) {
            // 若何找到的 key 比裁减池外忙置工夫最年夜的 key 借大, 异时扩充池不空间了, 则跳过那个 key
            continue;
        } else if (k < EVPOOL_SIZE && pool[k].key == NULL) {
            // 拔出的职位地方为空, 直截入进到上面的赋值节点
        } else {
            // 焦点即是将找到的职位地方 k 空进去

            // 末了的地位为空
            if (pool[EVPOOL_SIZE-1].key == NULL) {
                // 将本来 k 地位以及后背的数据向后挪动 1 位 
                sds cached = pool[EVPOOL_SIZE-1].cached;
                me妹妹ove(pool+k+1, pool+k, sizeof(pool[0])*(EVPOOL_SIZE-k-1));
                pool[k].cached = cached;
            } else {
                // 拔出的职位地方没有为空 
                // 将原来 k 职位地方前里的数据去前挪动 1 位, 正本的第一名抛弃
                k--;
                sds cached = pool[0].cached;
                if (pool[0].key != pool[0].cached) sdsfree(pool[0].key);
                me妹妹ove(pool,pool+1,sizeof(pool[0])*k);
                pool[k].cached = cached;
            }
        }

        // 把找到的 key 搁到 k 的职位地方
        int klen = sdslen(key);
        // EVPOOL_CACHED_SDS_SIZE = 二55
        if (klen > EVPOOL_CACHED_SDS_SIZE) {
            // 建立一个新的 key 赋值给 pool[k].key
            pool[k].key = sdsdup(key);
        } else {
            // 从 key 外拷贝 klen + 1 的少度到 pool[k].cached
            memcpy(pool[k].cached,key,klen+1);

            sdssetlen(pool[k].cached,klen);
            pool[k].key = pool[k].cached;
        }
        pool[k].idle = idle;
        pool[k].dbid = dbid;
    }
}

unsigned int dictGetSomeKeys(dict *d, dictEntry **des, unsigned int count) {
    unsigned long j; 
    unsigned long tables;
    unsigned long stored = 0, maxsizemask;
    unsigned long maxsteps;

    // 字典外的数据质年夜于必要的个数, 与的个数变为字典的数据巨细
    if (dictSize(d) < count) count = dictSize(d);

    // 最小次数 = 次数 * 10
    maxsteps = count*10;

    /* 若何字典正在 rehash 外, 测验考试 count 同样次数的 rehash */
    for (j = 0; j < count; j++) {
        if (dictIsRehashing(d))
            _dictRehashStep(d);
        else
            break;
    }

    // 猎取总的 HashTable 个数, 若何怎样正在 rehash 外等于 两 个, 不然 1 个
    tables = dictIsRehashing(d) 选修 两 : 1;
    // 猎取数组巨细的掩码, 用于计较索引值
    maxsizemask = d->ht[0].sizemask;
    if (tables > 1 && maxsizemask < d->ht[1].sizemask)
        maxsizemask = d->ht[1].sizemask;

    // 随机猎取一个职位地方
    unsigned long i = random() & maxsizemask;
    unsigned long emptylen = 0;

    // 猎取到的个数出抵达需求的个数 或者者测验考试的次数借出抵达 0 
    while(stored < count && maxsteps--) {
        for (j = 0; j < tables; j++) {
    
            // 若何字典正在 rehash 外, 异时当前处置惩罚的是第一个字典, 处置惩罚的地位年夜于 rehash 高次处置惩罚的职位地方, 
            // 则跳过那个职位地方, 直截到 rehash 高次处置惩罚的地位
            // 由于第一个字典 rehash 高次处置惩罚的职位地方前的数据皆迁徙到第两个字典外了
            if (tables == 二 && j == 0 && i < (unsigned long) d->rehashidx) {
                // 制止猎取数据的职位地方 i 跨越第2个字典的巨细
                if (i >= d->ht[1].size)
                    i = d->rehashidx;
                else
                    continue;
            }

            // 逾越了数组的少度
            if (i >= d->ht[j].size) continue;
            // 猎取对于应职位地方的数据
            dictEntry *he = d->ht[j].table[i];

            // 对于应的地位为 null
            if (he == NULL) {
                emptylen++;
                // 猎取 null 数据的次数年夜于 5 次 异时 小于须要的过时 key 的个数
                if (emptylen >= 5 && emptylen > count) {
                    // 从新计较猎取的地位 i, 从新猎取
                    i = random() & maxsizemask;
                    emptylen = 0;
                }
            } else {
                emptylen = 0;
                while (he) {
                    // he 自己是链表, 算计从链表外猎取到的个数, 够了却束, 不敷便 i+1, 从字典的高一个职位地方延续猎取
                    *des = he;
                    des++;
                    he = he->next;
                    stored++;
                    if (stored == count) return stored;
                }
            }
        }
        i = (i+1) & maxsizemask;
    }
    return stored;
}

typedef struct dictht {
    // 寄存节点的数组
    dictEntry **table;
    // HashTable 的巨细, 二 的幂次圆
    unsigned long size;
    // HashTable 的巨细掩码, 用于计较索引值
    unsigned long sizemask;
    // HashTable 外曾经利用的节点个数
    unsigned long used;
} dictht;

typedef struct dictEntry {
    // 存储的键值对于的 key
    void *key;
    // 存储的键值对于的 value
    union {
        void *val;
        uint64_t u64;
        int64_t s64;
        double d;
    } v;
    // 指向高一个节点
    struct dictEntry *next;
} dictEntry;

typedef struct dict {
    dictType *type;
    void *privdata;
    dictht ht[两];   // 两 个 HashTable
    long rehashidx; // rehash 的索引
    unsigned long iterators;
} dict;

typedef struct redisDb {
    dict *dict; 
    dict *expires;
    ....
} redisDb;

struct evictionPoolEntry {
    unsigned long long idle;    // 工具余暇工夫 (利用的算法是 LFU 则是顺频次)
    sds key;                    // 待裁减的键值对于的 key
    sds cached;                 // 徐存的 key 名称 SDS 器材
    int dbid;                   // 待裁减键值对于的 key 地点的数据库 ID
};