6. Redis在內存用完時會怎么辦？以及Redis如何處理已過期的數據？

楔子

在某些極端情況下，軟件為了能正常運行會做一些保護性的措施，比如運行內存超過最大值之后的處理，以及鍵值過期之后的處理等等，都屬於此類問題，而專業而全面的回答這些問題恰好是一個工程師所具備的優秀品質。

那么下面我們就來探討一下。

Redis內存用完了會怎么辦？

Redis 的內存用完指的是 Redis 使用的運行內存超過了 Redis 設置的最大內存，此值可以通過 Redis 的配置文件 redis.conf 進行設置，設置項為 maxmemory，我們可以使用 config get maxmemory 來查看設置的最大運行內存，如下所示：

127.0.0.1:6379> config get maxmemory
1) "maxmemory"
2) "0"
127.0.0.1:6379> 

config get是專門用來獲取配置的，config set是設置配置的。我們返回的結果為0，表示沒有內存大小限制，直到耗盡機器中所有的內存為止，這是 Redis 服務器端在 64 位操作系統下的默認值。

32 位操作系統，默認最大內存值為 3GB。

當 Redis 的內存用完之后就會觸發 Redis 的內存淘汰策略，執行流程如下圖所示：

最大內存的檢測源碼位於 server.c 中，核心代碼如下：

int processCommand(client *c) {
    // 最大內存檢測
    if (server.maxmemory && !server.lua_timedout) {
        int out_of_memory = freeMemoryIfNeededAndSafe() == C_ERR;
        if (server.current_client == NULL) return C_ERR;
        if (out_of_memory &&
            (c->cmd->flags & CMD_DENYOOM ||
             (c->flags & CLIENT_MULTI && c->cmd->proc != execCommand))) {
            flagTransaction(c);
            addReply(c, shared.oomerr);
            return C_OK;
        }
    }
    // 忽略其他代碼
}

Redis 內存淘汰策略可以使用 config get maxmemory-policy 命令來查看，如下所示：

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

從上述結果可以看出此 Redis 服務器采用的是 noeviction 策略，此策略表示當運行內存超過最大設置內存時，不淘汰任何數據，但新增操作會報錯。此策略為 Redis 默認的內存淘汰策略，此值可通過修改 redis.conf 文件進行修改。

關於淘汰策略，在前面介紹Redis配置文件的博客中，寫的比較詳細了。算了，還是再粘過來一次吧。

• volatile-lru：使用LRU(最近最少使用)策略移除keys，只針對過期的keys
• allkeys-lru：使用LRU(最近最少使用)策略移除keys
• volatile-lfu：使用LFU(最近最不常使用)策略移除keys，只針對過期的keys
• allkeys-lru：使用LFU(最近最不常使用)策略移除keys
• volatile-random：隨機移除一個過期的key
• allkeys-random：隨機移除一個任意key
• volatile-ttl：移除ttl值(過期時間)最少的key，即最快要過期的key
• noeviction：不移除任意key，僅僅在寫操作的時候返回一個error

Redis 的內存最大值和內存淘汰策略都可以通過配置文件進行修改，或者是使用命令行工具進行修改。使用命令行工具進行修改的優點是操作簡單，成功執行完命令之后設置的策略就會生效，我們可以使用 confg set 的方式進行設置，但它的缺點是不能進行持久化，也就是當 Redis 服務器重啟之后設置的策略就會丟失。另一種方式就是為配置文件修改的方式，此方式雖然較為麻煩，修改完之后要重啟 Redis 服務器才能生效，但優點是可持久化，重啟 Redis 服務器設置不會丟失。

關於LRU和LFU

內存淘汰策略決定了內存淘汰算法，從以上八種內存淘汰策略可以看出，它們中雖然具體的實現細節不同，但主要的淘汰算法有兩種：LRU 算法和 LFU 算法，我們分別介紹一下。

LRU算法

LRU 全稱是 Least Recently Used 譯為最近最少使用，是一種常用的頁面置換算法，選擇最近最久未使用的頁面予以淘汰。

1. LRU 算法實現

LRU 算法需要基於鏈表結構，鏈表中的元素按照操作順序從前往后排列，最新操作的鍵會被移動到表頭，當需要內存淘汰時，只需要刪除鏈表尾部的元素即可。

2. 近似LRU 算法

Redis 使用的是一種近似 LRU 算法，目的是為了更好的節約內存，它的實現方式是給現有的數據結構添加一個額外的字段，用於記錄此鍵值的最后一次訪問時間，Redis 內存淘汰時，會使用隨機采樣的方式來淘汰數據，它是隨機取 5 個值 (此值可配置) ，然后淘汰最久沒有使用的那個。

3. LRU 算法缺點

LRU 算法有一個缺點，比如說很久沒有使用的一個鍵值，如果最近被訪問了一次，那么它就不會被淘汰，即使它是使用次數最少的緩存，那它也不會被淘汰，因此在 Redis 4.0 之后引入了 LFU 算法，下面我們一起來看。

LFU算法

LFU 全稱是 Least Frequently Used 翻譯為最不常用的，最不常用的算法是根據總訪問次數來淘汰數據的，它的核心思想是"如果數據過去被訪問多次，那么將來被訪問的頻率也更高"。 LFU 解決了偶爾被訪問一次之后，數據就不會被淘汰的問題，相比於 LRU 算法也更合理一些。 在 Redis 中每個對象頭中記錄着 LFU 的信息，源碼如下：

typedef struct redisObject {
    unsigned type:4;
    unsigned encoding:4;
    unsigned lru:LRU_BITS; /* LRU time (relative to global lru_clock) or
                            * LFU data (least significant 8 bits frequency
                            * and most significant 16 bits access time). */
    int refcount;
    void *ptr;
} robj;

在 Redis 中 LFU 存儲分為兩部分，16 bit 的 ldt(last decrement time) 和 8 bit 的 logc(logistic counter)。

• 1. logc 是用來存儲訪問頻次, 8 bit 能表示的最大整數值為 255，它的值越小表示使用頻率越低，越容易淘汰；
• 2. ldt 是用來存儲上一次 logc 的更新時間。

至於 Redis 到底采用的是近 LRU 算法還是 LFU 算法，完全取決於內存淘汰策略的類型配置。

Redis如何處理已經過期的數據？

介紹完 Redis 內存用完之后的內存淘汰策略之后，我們再來看看 Redis 的鍵值過期之后的數據處理。這兩者是不同的，前者是在內存滿了的時候，對數據進行清理，算是異常情況；而后者是對鍵值過期之后的數據處理，算是正常情況下的數據清理。

問：Redis 如何處理已過期的數據？

在 Redis 中維護了一個過期字典，會將所有已經設置了過期時間的鍵值全部存儲到此字典中，我們使用設置過期時間的命令來舉個例子，命令如下：

127.0.0.1:6379> set name hanser ex 30
OK
127.0.0.1:6379> 

此命令表示 30s 之后鍵值為 name:hanser 的數據將會過期，其中 ex 是 expire 的縮寫，也就是過期、到期的意思。

過期時間除了上面的那種字符類型的直接設置之外，還可以使用 expire key seconds 的方式直接設置，示例如下：

127.0.0.1:6379> set age 28  # 先設置，此時默認永不過期
OK
127.0.0.1:6379> expire age 20  # 添加一個過期時間
(integer) 1
127.0.0.1:6379> 

所以我們根據一個鍵獲取對應值(簡單來說就是獲取鍵值)時，Redis會先判斷這個鍵值是否存在於過期字典中，如果沒有的話，表示鍵值沒有設置過期時間(永不過期)，於是直接返回數據；如果鍵值在過期字典中，那么會判斷當前時間是否小於過期時間，如果是，那么說明沒有過期會正常返回，反之表示數據已過期，於是會刪除該鍵值並返回nil。執行流程如下：

這是鍵值數據的獲取流程，同時也是過期鍵值的判斷和刪除的流程。

知識擴展

和此知識點相關的面試題還有以下這些：

• 常用的刪除策略有哪些？Redis 使用了什么刪除策略？
• Redis 中是如何存儲過期鍵的？

刪除策略

常見的過期策略，有以下三種：

• 1. 定時刪除
• 2. 惰性刪除
• 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 每次掃描並不是遍歷過期字典中的所有鍵，而是采用隨機抽取判斷並刪除過期鍵的形式執行的。

定期刪除流程如下：

• 1. 從過期字典中隨機取出 20 個鍵；
• 2. 刪除這 20 個鍵中過期的鍵；
• 3. 如果過期 key 的比例超過 25% ，重復步驟 1。

同時為了保證過期掃描不會出現循環過度，導致線程卡死現象，算法還增加了掃描時間的上限，默認不會超過 25ms。

定期刪除執行流程，如下圖所示：

• 優點：通過限制刪除操作的時長和頻率，來減少刪除操作對 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 本身的主線程是單線程執行的，如果因為刪除操作而影響主業務的執行就得不償失了，為此 Redis 需要制定多個過期刪除策略：惰性刪除加定期刪除的過期策略，來保證 Redis 能夠及時並高效的刪除 Redis 中的過期鍵。

過期鍵

過期鍵存儲在 redisDb 結構中，它的源碼位於 src/server.h 文件中：

// 源碼基於 Redis 5.x
typedef struct redisDb {
    dict *dict;                 /* 數據庫鍵空間，存放着所有的鍵值對 */
    dict *expires;              /* 鍵的過期時間 */
    dict *blocking_keys;        /* Keys with clients waiting for data (BLPOP)*/
    dict *ready_keys;           /* Blocked keys that received a PUSH */
    dict *watched_keys;         /* WATCHED keys for MULTI/EXEC CAS */
    int id;                     /* Database ID */
    long long avg_ttl;          /* Average TTL, just for stats */
    list *defrag_later;         /* List of key names to attempt to defrag one by one, gradually. */
} redisDb;

總結

這次我們介紹了三種常見的刪除策略：定時刪除、惰性刪除、定期刪除，其中定時刪除比較消耗系統性能，惰性刪除不能及時的清理過期數據從而導致了一定的空間浪費，為了兼顧存儲空間和性能，Redis 采用了惰性刪除加定期刪除的組合刪除策略，我們還通過 Redis 的源碼分析了 Redis 各個刪除策略的執行流程。當我們明白了 Redis 的過期刪除知識之后，再去理解它與 Redis 內存淘汰的區別就顯得非常容易了。