面試突擊 002 | Redis 是如何處理已過時元素的？

1 面試題

Redis 如何處理已過時的元素？
2 涉及知識點

此問題涉及如下知識點：

• 過時刪除策略有哪些？
• 這些過時策略有哪些優缺點？
• Redis 使用的是什麼過時策略？
• Redis 是如何優化和執行過時策略的？
  3 答案

常見的過時策略：

• 定時刪除
• 惰性刪除
• 按期刪除
  1）定時刪除

在設置鍵值過時時間時，建立一個定時事件，當過時時間到達時，由事件處理器自動執行鍵的刪除操做。
① 優勢

保證內存能夠被儘快的釋放
② 缺點

在 Redis 高負載的狀況下或有大量過時鍵須要同時處理時，會形成 Redis 服務器卡頓，影響主業務執行。
2）惰性刪除

不主動刪除過時鍵，每次從數據庫獲取鍵值時判斷是否過時，若是過時則刪除鍵值，並返回 null。
① 優勢

由於每次訪問時，纔會判斷過時鍵，因此此策略只會使用不多的系統資源。
② 缺點

系統佔用空間刪除不及時，致使空間利用率下降，形成了必定的空間浪費。
③ Redis 源碼解析

惰性刪除的源碼位於 src/db.c 文件的 expireIfNeeded 方法中，源碼以下：

int expireIfNeeded(redisDb *db, robj *key) {
    // 判斷鍵是否過時
    if (!keyIsExpired(db,key)) return 0;
    if (server.masterhost != NULL) return 1;
    /* 刪除過時鍵 */
    // 增長過時鍵個數
    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; /* No expire for this key */
    /* Don't expire anything while loading. It will be done later. */
    if (server.loading) return 0;
    mstime_t now = server.lua_caller ? server.lua_time_start : mstime();
    return now > when;
}
// 獲取鍵的過時時間
long long getExpire(redisDb *db, robj *key) {
    dictEntry *de;
    /* No expire? return ASAP */
    if (dictSize(db->expires) == 0 ||
       (de = dictFind(db->expires,key->ptr)) == NULL) return -1;
    /* The entry was found in the expire dict, this means it should also
     * be present in the main dict (safety check). */
    serverAssertWithInfo(NULL,key,dictFind(db->dict,key->ptr) != NULL);
    return dictGetSignedIntegerVal(de);
}

全部對數據庫的讀寫命令在執行以前，都會調用 expireIfNeeded 方法判斷鍵值是否過時，過時則會從數據庫中刪除，反之則不作任何處理。
3）按期刪除

每隔一段時間檢查一次數據庫，隨機刪除一些過時鍵。
Redis 默認每秒進行 10 次過時掃描，此配置可經過 Redis 的配置文件 redis.conf 進行配置，配置鍵爲 hz 它的默認值是 hz 10 。
須要注意的是：Redis 每次掃描並非遍歷過時字典中的全部鍵，而是採用隨機抽取判斷並刪除過時鍵的形式執行的。
按期刪除的執行流程：

① 優勢

經過限制刪除操做的時長和頻率，來減小刪除操做對 Redis 主業務的影響，同時也能刪除一部分過時的數據減小了過時鍵對空間的無效佔用。
② 缺點

內存清理方面沒有定時刪除效果好，同時沒有惰性刪除使用的系統資源少。
③ Redis 源碼解析

按期刪除的核心源碼在 src/expire.c 文件下的 activeExpireCycle 方法中，源碼以下：

void activeExpireCycle(int type) {
    static unsigned int current_db = 0; /* 上次按期刪除遍歷到的數據庫ID */
    static int timelimit_exit = 0;      /* Time limit hit in previous call? */
    static long long last_fast_cycle = 0; /* 上一次執行快速按期刪除的時間點 */
    int j, iteration = 0;
    int dbs_per_call = CRON_DBS_PER_CALL; // 每次按期刪除，遍歷的數據庫的數量
    long long start = ustime(), timelimit, elapsed;
    if (clientsArePaused()) return;
    if (type == ACTIVE_EXPIRE_CYCLE_FAST) {
        if (!timelimit_exit) return;
        // ACTIVE_EXPIRE_CYCLE_FAST_DURATION 是快速按期刪除的執行時長
        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;
    // 慢速按期刪除的執行時長
    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; /* 刪除操做的執行時長 */
    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;
            // 每一個數據庫中檢查的鍵的數量
            if (num > ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP)
                num = ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP;
            // 從數據庫中隨機選取 num 個鍵進行檢查
            while (num--) {
                dictEntry *de;
                long long ttl;
                if ((de = dictGetRandomKey(db->expires)) == NULL) break;
                ttl = dictGetSignedInteger
                // 過時檢查，並對過時鍵進行刪除
                if (activeExpireCycleTryExpire(db,de,now)) expired++;
                if (ttl > 0) {
                    /* We want the average TTL of keys yet not expired. */
                    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;
                }
            }
            /* 每次檢查只刪除 ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP/4 個過時鍵 */
        } while (expired > ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP/4);
    }
    // .......
}

activeExpireCycle 方法在規定的時間，分屢次遍歷各個數據庫，從過時字典中隨機檢查一部分過時鍵的過時時間，刪除其中的過時鍵。
這個函數有兩種執行模式，一個是快速模式一個是慢速模式，體現是代碼中的 timelimit 變量，這個變量是用來約束此函數的運行時間的。快速模式下 timelimit 的值是固定的，等於預約義常量 ACTIVE_EXPIRE_CYCLE_FAST_DURATION，慢速模式下，這個變量的值是經過 1000000*ACTIVE_EXPIRE_CYCLE_SLOW_TIME_PERC/server.hz/100 計算的。
總結

本文講了常見的過時刪除策略：

• 定時刪除
• 惰性刪除
• 按期刪除 而 Redis 使用的是惰性刪除 + 按期刪除的組合策略。
  【END】
  近期熱文

面試珍藏：最多見的200多道Java面試題(2019年最新版)
Java面試詳解(2020版)：500+ 面試題和核心知識點詳解
面試突擊 | Redis 如何從海量數據中查詢出某一個 Key？視頻版
關注下方二維碼，訂閱更多精彩內容