int freeMemoryIfNeeded(void) {
    /**
     * noeviction 不淘汰數(shù)據(jù)，什么都不做
     */
    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關(guān)聯(lián)的哈希表
             */
            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);
            }
            /**
             * 分支二：全局哈希表隨機或者過期時間哈希表中，隨機采樣多個數(shù)據(jù)，再運用lru算法挑選一個淘汰
             */
            else if (server.maxmemory_policy == MAXMEMORY_ALLKEYS_LRU ||
                server.maxmemory_policy == MAXMEMORY_VOLATILE_LRU)
            {
                /* 樣本集 */
                struct evictionPoolEntry *pool = db->eviction_pool;
                while(bestkey == NULL) {
                    /* 
                     * 采樣，更新和維護樣本集；
                     * 樣本集開始是空的，每次操作完并不會清空樣本集；
                     * 而且每次采樣，都會采集多個數(shù)據(jù)，同時和樣本集中已有的數(shù)據(jù)進行比較，新增或者更新樣本集；
                     */ 
                    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樣本集內(nèi)的key，只是樣本，不一定和db內(nèi)保持一致，也不必，可能在db中已經(jīng)被刪除的，所以要作判斷 */
                        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;
}