typedef redisServer {
    ....
    // Redis數(shù)據(jù)庫
    redisDb *db;
    ....
}

typedef struct redisClient {
    // 套接字描述符
    int fd;
    // 當(dāng)前正在使用的數(shù)據(jù)庫
    redisDb *db;
    // 當(dāng)前正在使用的數(shù)據(jù)庫的 id （號碼）
    int dictid;
    // 客戶端的名字
    robj *name;             /* As set by CLIENT SETNAME */
} redisClient;

redis> SELECT 1
Ok
redis[1]>

typedef struct redisDb {
    //數(shù)據(jù)庫鍵空間
    dict *dict;                 /* The keyspace for this DB */
    //鍵的過期時(shí)間，字典的值為過期事件 UNIX 時(shí)間戳
    dict *expires;              /* Timeout of keys with a timeout set */
    //正處于阻塞狀態(tài)的鍵
    dict *blocking_keys;        /* Keys with clients waiting for data (BLPOP)*/
    //可以解除阻塞的鍵
    dict *ready_keys;           /* Blocked keys that received a PUSH */
    //正在被 WATCH 命令監(jiān)視的鍵
    dict *watched_keys;         /* WATCHED keys for MULTI/EXEC CAS */
    //數(shù)據(jù)庫號端
    int id;                     /* Database ID */
    //數(shù)據(jù)庫鍵的平均 TTL，統(tǒng)計(jì)信息
    long long avg_ttl;          /* Average TTL, just for stats */
    //
    unsigned long expires_cursor; /* Cursor of the active expire cycle. */
    list *defrag_later;         /* List of key names to attempt to defrag one by one, gradually. */
} redisDb;

# 插入一個(gè)字符串對象
redis> SET message "hello world"
OK
# 插入包含三個(gè)元素的列表對象
redis> RPUSH alphabet "a" "b" "c"
(integer)3
# 插入包含三個(gè)元素的哈希表對象
redis> HSET book name "Redis in Action"
(integer) 1
redis> HSET book author "Josiah L. Carlson"
(integer) 1
redis> HSET book publisher "Manning"
(integer) 1

redis> set key value
OK
# 設(shè)置鍵的 TTL 為 5
redis> EXPIRE key 5
(integer)1

redis> SET key value
OK
redis> EXPIREAT key 1377257300
(integer) 1
# 當(dāng)前系統(tǒng)時(shí)間
redis> TIME
1)"1377257296"
# 過一段時(shí)間后，再查詢key 
redis> GET key // 1377257300
(nil)

int expireIfNeeded(redisDb *db, robj *key) {
    // 判斷鍵是否過期
    if (!keyIsExpired(db,key)) return 0;
    if (server.masterhost != NULL) return 1;
    /* 刪除過期鍵 */
    // 增加過期鍵個(gè)數(shù)
    server.stat_expiredkeys++;
    // 傳播鍵過期的消息
    propagateExpire(db,key,server.lazyfree_lazy_expire);
    notifyKeyspaceEvent(NOTIFY_EXPIRED,
        "expired",key,db->id);
    // server.lazyfree_lazy_expire 為 1 表示異步刪除，否則則為同步刪除
    return server.lazyfree_lazy_expire ? dbAsyncDelete(db,key) :
                                         dbSyncDelete(db,key);
}
// 判斷鍵是否過期
int keyIsExpired(redisDb *db, robj *key) {
    mstime_t when = getExpire(db,key);
    if (when < 0) return 0; 
    if (server.loading) return 0;
    mstime_t now = server.lua_caller ? server.lua_time_start : mstime();
    return now > when;
}
// 獲取鍵的過期時(shí)間
long long getExpire(redisDb *db, robj *key) {
    dictEntry *de;
    if (dictSize(db->expires) == 0 ||
       (de = dictFind(db->expires,key->ptr)) == NULL) return -1;
    serverAssertWithInfo(NULL,key,dictFind(db->dict,key->ptr) != NULL);
    return dictGetSignedIntegerVal(de);
}

void activeExpireCycle(int type) {
    static unsigned int current_db = 0; /* 上次定期刪除遍歷到的數(shù)據(jù)庫ID */
    static int timelimit_exit = 0;      
    static long long last_fast_cycle = 0; /* 上次執(zhí)行定期刪除的時(shí)間點(diǎn) */
    int j, iteration = 0;
    int dbs_per_call = CRON_DBS_PER_CALL; // 需要遍歷數(shù)據(jù)庫的數(shù)量
    long long start = ustime(), timelimit, elapsed;
    if (clientsArePaused()) return;
    if (type == ACTIVE_EXPIRE_CYCLE_FAST) {
        if (!timelimit_exit) return;
        // ACTIVE_EXPIRE_CYCLE_FAST_DURATION 快速定期刪除的執(zhí)行時(shí)長
        if (start < last_fast_cycle + ACTIVE_EXPIRE_CYCLE_FAST_DURATION*2) return;
        last_fast_cycle = start;
    }
    if (dbs_per_call > server.dbnum || timelimit_exit)
        dbs_per_call = server.dbnum;
    // 慢速定期刪除的執(zhí)行時(shí)長
    timelimit = 1000000*ACTIVE_EXPIRE_CYCLE_SLOW_TIME_PERC/server.hz/100;
    timelimit_exit = 0;
    if (timelimit <= 0) timelimit = 1;
    if (type == ACTIVE_EXPIRE_CYCLE_FAST)
        timelimit = ACTIVE_EXPIRE_CYCLE_FAST_DURATION; /* 刪除操作花費(fèi)的時(shí)間 */
    long total_sampled = 0;
    long total_expired = 0;
    for (j = 0; j < dbs_per_call && timelimit_exit == 0; j++) {
        int expired;
        redisDb *db = server.db+(current_db % server.dbnum);
        current_db++;
        do {
            // .......
            expired = 0;
            ttl_sum = 0;
            ttl_samples = 0;
            // 每個(gè)數(shù)據(jù)庫中檢查的鍵的數(shù)量
            if (num > ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP)
                num = ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP;
            // 從數(shù)據(jù)庫中隨機(jī)選取 num 個(gè)鍵進(jìn)行檢查
            while (num--) {
                dictEntry *de;
                long long ttl;
                if ((de = dictGetRandomKey(db->expires)) == NULL) break;
                ttl = dictGetSignedInteger
                // 過期檢查，并對過期鍵進(jìn)行刪除
                if (activeExpireCycleTryExpire(db,de,now)) expired++;
                if (ttl > 0) {
                    ttl_sum += ttl;
                    ttl_samples++;
                }
                total_sampled++;
            }
            total_expired += expired;
            if (ttl_samples) {
                long long avg_ttl = ttl_sum/ttl_samples;
                if (db->avg_ttl == 0) db->avg_ttl = avg_ttl;
                db->avg_ttl = (db->avg_ttl/50)*49 + (avg_ttl/50);
            }
            if ((iteration & 0xf) == 0) { /* check once every 16 iterations. */
                elapsed = ustime()-start;
                if (elapsed > timelimit) {
                    timelimit_exit = 1;
                    server.stat_expired_time_cap_reached_count++;
                    break;
                }
            }
            /* 判斷過期鍵刪除數(shù)量是否超過 25% */
        } while (expired > ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP/4);
    }
    // .......
}

127.0.0.1:6379> config get maxmemory-policy
1) "maxmemory-policy"
2) "noeviction"