詳解 Redis 內存管理機制和實現(xiàn)

作者：歷小冰 2020-08-18 19:15:44

Redis是一個基于內存的鍵值數(shù)據(jù)庫，其內存管理是非常重要的。本文內存管理的內容包括：過期鍵的懶性刪除和過期刪除以及內存溢出控制策略。

本文轉載自微信公眾號「程序員歷小冰」，作者歷小冰。轉載本文請聯(lián)系程序員歷小冰公眾號。

最大內存限制

Redis使用 maxmemory 參數(shù)限制最大可用內存，默認值為0，表示無限制。限制內存的目的主要有：

用于緩存場景，當超出內存上限 maxmemory 時使用 LRU 等刪除策略釋放空間。
防止所用內存超過服務器物理內存。因為 Redis 默認情況下是會盡可能多使用服務器的內存，可能會出現(xiàn)服務器內存不足，導致 Redis 進程被殺死。

maxmemory 限制的是Redis實際使用的內存量，也就是 used_memory統(tǒng)計項對應的內存。由于內存碎片率的存在，實際消耗的內存可能會比maxmemory設置的更大，實際使用時要小心這部分內存溢出。具體Redis 內存監(jiān)控的內容請查看一文了解 Redis 內存監(jiān)控和內存消耗。

Redis默認無限使用服務器內存，為防止極端情況下導致系統(tǒng)內存耗盡，建議所有的Redis進程都要配置maxmemory。在保證物理內存可用的情況下，系統(tǒng)中所有Redis實例可以調整 maxmemory參數(shù)來達到自由伸縮內存的目的。

內存回收策略

Redis 回收內存大致有兩個機制：一是刪除到達過期時間的鍵值對象;二是當內存達到 maxmemory 時觸發(fā)內存移除控制策略，強制刪除選擇出來的鍵值對象。

刪除過期鍵對象

Redis 所有的鍵都可以設置過期屬性，內部保存在過期表中，鍵值表和過期表的結果如下圖所示。當 Redis保存大量的鍵，對每個鍵都進行精準的過期刪除可能會導致消耗大量的 CPU，會阻塞 Redis 的主線程，拖累 Redis 的性能，因此 Redis 采用惰性刪除和定時任務刪除機制實現(xiàn)過期鍵的內存回收。

惰性刪除是指當客戶端操作帶有超時屬性的鍵時，會檢查是否超過鍵的過期時間，然后會同步或者異步執(zhí)行刪除操作并返回鍵已經過期。這樣可以節(jié)省 CPU成本考慮，不需要單獨維護過期時間鏈表來處理過期鍵的刪除。

過期鍵的惰性刪除策略由 db.c/expireifNeeded 函數(shù)實現(xiàn)，所有對數(shù)據(jù)庫的讀寫命令執(zhí)行之前都會調用 expireifNeeded 來檢查命令執(zhí)行的鍵是否過期。如果鍵過期，expireifNeeded 會將過期鍵從鍵值表和過期表中刪除，然后同步或者異步釋放對應對象的空間。源碼展示的時 Redis 4.0 版本。

expireIfNeeded 先從過期表中獲取鍵對應的過期時間，如果當前時間已經超過了過期時間(lua腳本執(zhí)行則有特殊邏輯，詳看代碼注釋)，則進入刪除鍵流程。刪除鍵流程主要進行了三件事：

一是刪除操作命令傳播，通知 slave 實例并存儲到 AOF 緩沖區(qū)中
二是記錄鍵空間事件，
三是根據(jù) lazyfreelazyexpire 是否開啟進行異步刪除或者異步刪除操作。

int expireIfNeeded(redisDb *db, robj *key) { 
 
// 獲取鍵的過期時間 
 
mstime_t when = getExpire(db,key); 
 
mstime_t now; 
 
// 鍵沒有過期時間 
 
if (when < 0) return 0; 
 
// 實例正在從硬盤 laod 數(shù)據(jù)，比如說 RDB 或者 AOF 
 
if (server.loading) return 0; 
 
 
 
 
// 當執(zhí)行l(wèi)ua腳本時，只有鍵在lua一開始執(zhí)行時 
 
// 就到了過期時間才算過期，否則在lua執(zhí)行過程中不算失效 
 
now = server.lua_caller ? server.lua_time_start : mstime(); 
 
 
 
 
// 當本實例是slave時，過期鍵的刪除由master發(fā)送過來的 
 
// del 指令控制。但是這個函數(shù)還是將正確的信息返回給調用者。 
 
if (server.masterhost != NULL) return now > when; 
 
// 判斷是否未過期 
 
if (now <= when) return 0; 
 
 
 
 
// 代碼到這里，說明鍵已經過期，而且需要被刪除 
 
server.stat_expiredkeys++; 
 
// 命令傳播，到 slave 和 AOF 
 
propagateExpire(db,key,server.lazyfree_lazy_expire); 
 
// 鍵空間通知使得客戶端可以通過訂閱頻道或模式， 來接收那些以某種方式改動了 Redis 數(shù)據(jù)集的事件。 
 
notifyKeyspaceEvent(NOTIFY_EXPIRED, 
 
"expired",key,db->id); 
 
// 如果是惰性刪除，調用dbAsyncDelete，否則調用 dbSyncDelete 
 
return server.lazyfree_lazy_expire ? dbAsyncDelete(db,key) : 
 
dbSyncDelete(db,key); 
 
}

上圖是寫命令傳播的示意圖，刪除命令的傳播和它一致。propagateExpire 函數(shù)先調用 feedAppendOnlyFile 函數(shù)將命令同步到 AOF 的緩沖區(qū)中，然后調用 replicationFeedSlaves函數(shù)將命令同步到所有的 slave 中。Redis 復制的機制可以查看Redis 復制過程詳解。

// 將命令傳遞到slave和AOF緩沖區(qū)。maser刪除一個過期鍵時會發(fā)送Del命令到所有的slave和AOF緩沖區(qū) 
 
void propagateExpire(redisDb *db, robj *key, int lazy) { 
 
robj *argv[2]; 
 
// 生成同步的數(shù)據(jù) 
 
argv[0] = lazy ? shared.unlink : shared.del; 
 
argv[1] = key; 
 
incrRefCount(argv[0]); 
 
incrRefCount(argv[1]); 
 
// 如果開啟了 AOF 則追加到 AOF 緩沖區(qū)中 
 
if (server.aof_state != AOF_OFF) 
 
feedAppendOnlyFile(server.delCommand,db->id,argv,2); 
 
// 同步到所有 slave 
 
replicationFeedSlaves(server.slaves,db->id,argv,2); 
 
 
 
 
decrRefCount(argv[0]); 
 
decrRefCount(argv[1]); 
 
}

dbAsyncDelete 函數(shù)會先調用 dictDelete 來刪除過期表中的鍵，然后處理鍵值表中的鍵值對象。它會根據(jù)值的占用的空間來選擇是直接釋放值對象，還是交給 bio 異步釋放值對象。判斷依據(jù)就是值的估計大小是否大于 LAZYFREE_THRESHOLD 閾值。鍵對象和 dictEntry 對象則都是直接被釋放。

#define LAZYFREE_THRESHOLD 64 
 
int dbAsyncDelete(redisDb *db, robj *key) { 
 
// 刪除該鍵在過期表中對應的entry 
 
if (dictSize(db->expires) > 0) dictDelete(db->expires,key->ptr); 
 
 
 
 
// unlink 該鍵在鍵值表對應的entry 
 
dictEntry *de = dictUnlink(db->dict,key->ptr); 
 
// 如果該鍵值占用空間非常小，懶刪除反而效率低。所以只有在一定條件下，才會異步刪除 
 
if (de) { 
 
robj *val = dictGetVal(de); 
 
size_t free_effort = lazyfreeGetFreeEffort(val); 
 
// 如果釋放這個對象消耗很多，并且值未被共享(refcount == 1)則將其加入到懶刪除列表 
 
if (free_effort > LAZYFREE_THRESHOLD && val->refcount == 1) { 
 
atomicIncr(lazyfree_objects,1); 
 
bioCreateBackgroundJob(BIO_LAZY_FREE,val,NULL,NULL); 
 
dictSetVal(db->dict,de,NULL); 
 
} 
 
} 
 
 
 
 
// 釋放鍵值對，或者只釋放key，而將val設置為NULL來后續(xù)懶刪除 
 
if (de) { 
 
dictFreeUnlinkedEntry(db->dict,de); 
 
// slot 和 key 的映射關系是用于快速定位某個key在哪個 slot中。 
 
if (server.cluster_enabled) slotToKeyDel(key); 
 
return 1; 
 
} else { 
 
return 0; 
 
} 
 
}

dictUnlink 會將鍵值從鍵值表中刪除，但是卻不釋放 key、val和對應的表entry對象，而是將其直接返回，然后再調用dictFreeUnlinkedEntry進行釋放。dictDelete 是它的兄弟函數(shù)，但是會直接釋放相應的對象。二者底層都通過調用 dictGenericDelete來實現(xiàn)。dbAsyncDelete d的兄弟函數(shù) dbSyncDelete 就是直接調用dictDelete來刪除過期鍵。

void dictFreeUnlinkedEntry(dict *d, dictEntry *he) { 
 
if (he == NULL) return; 
 
// 釋放key對象 
 
dictFreeKey(d, he); 
 
// 釋放值對象，如果它不為null 
 
dictFreeVal(d, he); 
 
// 釋放 dictEntry 對象 
 
zfree(he); 
 
}

Redis 有自己的 bio 機制，主要是處理 AOF 落盤、懶刪除邏輯和關閉大文件fd。bioCreateBackgroundJob 函數(shù)將釋放值對象的 job 加入到隊列中，bioProcessBackgroundJobs會從隊列中取出任務，根據(jù)類型進行對應的操作。

void *bioProcessBackgroundJobs(void *arg) { 
 
..... 
 
while(1) { 
 
listNode *ln; 
 
 
 
 
ln = listFirst(bio_jobs[type]); 
 
job = ln->value; 
 
if (type == BIO_CLOSE_FILE) { 
 
close((long)job->arg1); 
 
} else if (type == BIO_AOF_FSYNC) { 
 
aof_fsync((long)job->arg1); 
 
} else if (type == BIO_LAZY_FREE) { 
 
// 根據(jù)參數(shù)來決定要做什么。有參數(shù)1則要釋放它， 
 
// 有參數(shù)2和3是釋放兩個鍵值表 
 
// 過期表，也就是釋放db 只有參數(shù)三是釋放跳表 
 
if (job->arg1) 
 
lazyfreeFreeObject 
 
FromBioThread(job->arg1); 
 
else if (job->arg2 && job->arg3) 
 
lazyfreeFreeDatabase 
 
FromBioThread(job->arg2,job->arg3); 
 
else if (job->arg3) 
 
lazyfreeFreeSlotsMap 
 
FromBioThread(job->arg3); 
 
} 
 
zfree(job); 
 
...... 
 
} 
 
}

dbSyncDelete 則是直接刪除過期鍵，并且將鍵、值和 DictEntry 對象都釋放。

int dbSyncDelete(redisDb *db, robj *key) { 
 
// 刪除過期表中的entry 
 
if (dictSize(db->expires) > 0) dictDelete(db->expires,key->ptr); 
 
// 刪除鍵值表中的entry 
 
if (dictDelete(db->dict,key->ptr) == DICT_OK) { 
 
// 如果開啟了集群，則刪除slot 和 key 映射表中key記錄。 
 
if (server.cluster_enabled) slotToKeyDel(key); 
 
return 1; 
 
} else { 
 
return 0; 
 
} 
 
}

但是單獨用這種方式存在內存泄露的問題，當過期鍵一直沒有訪問將無法得到及時刪除，從而導致內存不能及時釋放。正因為如此，Redis還提供另一種定時任務刪除機制作為惰性刪除的補充。

Redis 內部維護一個定時任務，默認每秒運行10次(通過配置控制)。定時任務中刪除過期鍵邏輯采用了自適應算法，根據(jù)鍵的過期比例、使用快慢兩種速率模式回收鍵，流程如下圖所示。

1)定時任務首先根據(jù)快慢模式( 慢模型掃描的鍵的數(shù)量以及可以執(zhí)行時間都比快模式要多 )和相關閾值配置計算計算本周期最大執(zhí)行時間、要檢查的數(shù)據(jù)庫數(shù)量以及每個數(shù)據(jù)庫掃描的鍵數(shù)量。
2) 從上次定時任務未掃描的數(shù)據(jù)庫開始，依次遍歷各個數(shù)據(jù)庫。
3)從數(shù)據(jù)庫中隨機選手 ACTIVEEXPIRECYCLELOOKUPSPER_LOOP 個鍵，如果發(fā)現(xiàn)是過期鍵，則調用 activeExpireCycleTryExpire 函數(shù)刪除它。
4)如果執(zhí)行時間超過了設定的最大執(zhí)行時間，則退出，并設置下一次使用慢模式執(zhí)行。
5)未超時的話，則判斷是否采樣的鍵中是否有25%的鍵是過期的，如果是則繼續(xù)掃描當前數(shù)據(jù)庫，跳到第3步。否則開始掃描下一個數(shù)據(jù)庫。

定期刪除策略由 expire.c/activeExpireCycle 函數(shù)實現(xiàn)。在redis事件驅動的循環(huán)中的eventLoop->beforesleep和周期性操作 databasesCron 都會調用 activeExpireCycle 來處理過期鍵。但是二者傳入的 type 值不同，一個是ACTIVEEXPIRECYCLESLOW 另外一個是ACTIVEEXPIRECYCLEFAST。activeExpireCycle 在規(guī)定的時間，分多次遍歷各個數(shù)據(jù)庫，從 expires 字典中隨機檢查一部分過期鍵的過期時間，刪除其中的過期鍵，相關源碼如下所示。

void activeExpireCycle(int type) { 
 
// 上次檢查的db 
 
static unsigned int current_db = 0;  
 
// 上次檢查的最大執(zhí)行時間 
 
static int timelimit_exit = 0; 
 
// 上一次快速模式運行時間 
 
static long long last_fast_cycle = 0; /* When last fast cycle ran. */ 
 
 
 
 
int j, iteration = 0; 
 
// 每次檢查周期要遍歷的DB數(shù) 
 
int dbs_per_call = CRON_DBS_PER_CALL; 
 
long long start = ustime(), timelimit, elapsed; 
 
 
 
 
..... // 一些狀態(tài)時不進行檢查，直接返回 
 
 
 
 
// 如果上次周期因為執(zhí)行達到了最大執(zhí)行時間而退出，則本次遍歷所有db,否則遍歷db數(shù)等于 CRON_DBS_PER_CALL 
 
if (dbs_per_call > server.dbnum || timelimit_exit) 
 
dbs_per_call = server.dbnum; 
 
 
 
 
// 根據(jù)ACTIVE_EXPIRE_CYCLE_SLOW_TIME_PERC計算本次最大執(zhí)行時間 
 
timelimit = 1000000*ACTIVE_EXPIRE_CYCLE_SLOW_TIME_PERC/server.hz/100; 
 
timelimit_exit = 0; 
 
if (timelimit <= 0) timelimit = 1; 
 
// 如果是快速模式，則最大執(zhí)行時間為ACTIVE_EXPIRE_CYCLE_FAST_DURATION 
 
if (type == ACTIVE_EXPIRE_CYCLE_FAST) 
 
timelimit = ACTIVE_EXPIRE_CYCLE_FAST_DURATION; /* in microseconds. */ 
 
// 采樣記錄 
 
long total_sampled = 0; 
 
long total_expired = 0; 
 
// 依次遍歷 dbs_per_call 個 db 
 
for (j = 0; j < dbs_per_call && timelimit_exit == 0; j++) { 
 
int expired; 
 
redisDb *db = server.db+(current_db % server.dbnum); 
 
// 將db數(shù)增加，一遍下一次繼續(xù)從這個db開始遍歷 
 
current_db++; 
 
 
 
 
do { 
 
..... // 申明變量和一些情況下 break 
 
if (num > ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP) 
 
num = ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP; 
 
// 主要循環(huán)，在過期表中進行隨機采樣，判斷是否比率大于25% 
 
while (num--) { 
 
dictEntry *de; 
 
long long ttl; 
 
 
 
 
if ((de = dictGetRandomKey(db->expires)) == NULL) break; 
 
ttl = dictGetSignedIntegerVal(de)-now; 
 
// 刪除過期鍵 
 
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++; 
 
} 
 
// 記錄過期總數(shù) 
 
total_expired += expired; 
 
// 即使有很多鍵要過期，也不阻塞很久，如果執(zhí)行超過了最大執(zhí)行時間，則返回 
 
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; 
 
} 
 
} 
 
// 當比率小于25%時返回 
 
} while (expired > ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP/4); 
 
} 
 
.....// 更新一些server的記錄數(shù)據(jù) 
 
}

activeExpireCycleTryExpire 函數(shù)的實現(xiàn)就和 expireIfNeeded 類似，這里就不贅述了。

int activeExpireCycleTryExpire(redisDb *db, dictEntry *de, long long now) { 
 
long long t = dictGetSignedIntegerVal(de); 
 
if (now > t) { 
 
sds key = dictGetKey(de); 
 
robj *keyobj = createStringObject(key,sdslen(key)); 
 
 
 
 
propagateExpire(db,keyobj,server.lazyfree_lazy_expire); 
 
if (server.lazyfree_lazy_expire) 
 
dbAsyncDelete(db,keyobj); 
 
else 
 
dbSyncDelete(db,keyobj); 
 
notifyKeyspaceEvent(NOTIFY_EXPIRED, 
 
"expired",keyobj,db->id); 
 
decrRefCount(keyobj); 
 
server.stat_expiredkeys++; 
 
return 1; 
 
} else { 
 
return 0; 
 
} 
 
}

定期刪除策略的關鍵點就是刪除操作執(zhí)行的時長和頻率：

如果刪除操作太過頻繁或者執(zhí)行時間太長，就對 CPU 時間不是很友好，CPU 時間過多的消耗在刪除過期鍵上。
如果刪除操作執(zhí)行太少或者執(zhí)行時間太短，就不能及時刪除過期鍵，導致內存浪費。

內存溢出控制策略

當Redis所用內存達到maxmemory上限時會觸發(fā)相應的溢出控制策略。具體策略受maxmemory-policy參數(shù)控制，Redis支持6種策略，如下所示：

1)noeviction：默認策略，不會刪除任何數(shù)據(jù)，拒絕所有寫入操作并返回客戶端錯誤信息(error)OOM command not allowed when used memory，此時Redis只響應讀操作。
2)volatile-lru：根據(jù)LRU算法刪除設置了超時屬性(expire)的鍵，直到騰出足夠空間為止。如果沒有可刪除的鍵對象，回退到noeviction策略。
3)allkeys-lru：根據(jù)LRU算法刪除鍵，不管數(shù)據(jù)有沒有設置超時屬性，直到騰出足夠空間為止。
4)allkeys-random：隨機刪除所有鍵，直到騰出足夠空間為止。
5)volatile-random：隨機刪除過期鍵，直到騰出足夠空間為止。
6)volatile-ttl：根據(jù)鍵值對象的ttl屬性，刪除最近將要過期數(shù)據(jù)。如果沒有，回退到noeviction策略。

內存溢出控制策略可以使用 config set maxmemory-policy {policy} 語句進行動態(tài)配置。Redis 提供了豐富的空間溢出控制策略，我們可以根據(jù)自身業(yè)務需要進行選擇。

當設置 volatile-lru 策略時，保證具有過期屬性的鍵可以根據(jù) LRU 剔除，而未設置超時的鍵可以永久保留。還可以采用allkeys-lru 策略把 Redis 變?yōu)榧兙彺娣掌魇褂谩?/p>

當Redis因為內存溢出刪除鍵時，可以通過執(zhí)行 info stats 命令查看 evicted_keys 指標找出當前 Redis 服務器已剔除的鍵數(shù)量。

每次Redis執(zhí)行命令時如果設置了maxmemory參數(shù)，都會嘗試執(zhí)行回收內存操作。當Redis一直工作在內存溢出(used_memory>maxmemory)的狀態(tài)下且設置非 noeviction 策略時，會頻繁地觸發(fā)回收內存的操作，影響Redis 服務器的性能，這一點千萬要引起注意。

責任編輯：武曉燕來源：程序員歷小冰

Redis 內存管理