Redis データ削除戦略の詳細な説明

この記事で説明しているのは、redis が最大メモリを設定した後、キャッシュ内のデータ セットのサイズが一定の割合を超え、実装される排除戦略は、期限切れのキーの削除 どちらも非常に似ていますが。 (推奨: redis ビデオ チュートリアル )

redis では、ユーザーは redis.conf で maxmemory 値を構成することで最大メモリ サイズを設定し、メモリ削除機能を有効にすることができます。状況。

最大メモリ サイズを設定すると、redis が安定したサービスを外部に提供できるようになります。

redis メモリ データ セットのサイズが特定のサイズに増加すると、データ削除戦略が実装されます。 Redis は、maxmemory-policy 設定戦略を通じて 6 つのデータ削除戦略を提供します。

volatile-lru: 削除する有効期限が設定されたデータセット (server.db[i].expires) から最も最近使用されていないデータを選択します。

volatile-ttl: 有効期限を設定したデータセット(server.db[i].expires)から有効期限が切れるデータを選択します

volatile-random: データを選択しますデータ セット (server.db[i].expires) から任意のデータを選択して除外します。

allkeys-lru: データ セット (サーバー) から最も最近使用されていないデータを選択します。 .db[i].dict) for Elimination

allkeys-random: データセット (server.db[i].dict) から任意にデータを選択して、

no-enviction (エビクション) を排除します。 ): データのエビクションを禁止します

redis キーと値のペアを追い出すことが決定された後、データは削除され、データ変更メッセージがローカル (AOF 永続性) とスレーブ (マスター) に発行されます。 -slave接続)

#LRUデータ削除メカニズム

lruカウンターserver.lrulockはサーバー構成に保存され、定期的に更新されます(redisタイマープログラムserverCorn() ).server.lrulock の値は、server.unixtime に基づいて計算されます。

さらに、struct redisObject から、各 redis オブジェクトが対応する lru を設定することがわかります。 redisObject.lru はデータにアクセスされるたびに更新されることが考えられます。

LRU データ削除メカニズムは次のとおりです。データ セット内のいくつかのキーと値のペアをランダムに選択し、その中で最大の lru を持つキーと値のペアを削除します。したがって、redis はすべてのデータ セットで最も最近使用されていない (LRU) キーと値のペアを取得することを保証するのではなく、ランダムに選択された少数のキーと値のペアのみを取得することを保証していることがわかります。

// redisServer 保存了 lru 计数器
struct redisServer {
...
unsigned lruclock:22; /* Clock incrementing every minute, for LRU */
...
};
// 每一个 redis 对象都保存了 lru
#define REDIS_LRU_CLOCK_MAX ((1<<21)-1) /* Max value of obj->lru */
#define REDIS_LRU_CLOCK_RESOLUTION 10 /* LRU clock resolution in seconds */
typedef struct redisObject {
// 刚刚好 32 bits
// 对象的类型，字符串/列表/集合/哈希表
unsigned type:4;
// 未使用的两个位
unsigned notused:2; /* Not used */
// 编码的方式，redis 为了节省空间，提供多种方式来保存一个数据
// 譬如：“123456789” 会被存储为整数 123456789
unsigned encoding:4;
unsigned lru:22; /* lru time (relative to server.lruclock) */
// 引用数
int refcount;
// 数据指针
void *ptr;

} robj;
// redis 定时执行程序。联想：linux cron
int serverCron(struct aeEventLoop *eventLoop, long long id, void *clientData) {
......
/* We have just 22 bits per object for LRU information.
* So we use an (eventually wrapping) LRU clock with 10 seconds resolution.
* 2^22 bits with 10 seconds resolution is more or less 1.5 years.
*
* Note that even if this will wrap after 1.5 years it&#39;s not a problem,
* everything will still work but just some object will appear younger
* to Redis. But for this to happen a given object should never be touched
* for 1.5 years.
*
* Note that you can change the resolution altering the
* REDIS_LRU_CLOCK_RESOLUTION define.

*/
updateLRUClock();
......
}
// 更新服务器的 lru 计数器
void updateLRUClock(void) {
server.lruclock = (server.unixtime/REDIS_LRU_CLOCK_RESOLUTION) &
REDIS_LRU_CLOCK_MAX;
}

TTL データ削除メカニズム

Redis データ セット データ構造内のテーブルには、キーと値のペアの有効期限 (redisDb.expires) が格納されます。 LRU データ削除メカニズムと同様に、TTL データ削除メカニズムは次のとおりです。有効期限テーブルからいくつかのキーと値のペアをランダムに選択し、最も大きい ttl を持つキーと値のペアを取り出して削除します。

同様に、redis がすべての有効期限テーブルで最も早く期限切れになるキーと値のペアを取得することは保証されておらず、ランダムに選択された少数のキーと値のペアのみを取得することがわかります。

概要

各 Redis サービス クライアントはコマンドを実行するときに、使用されているメモリが過剰かどうかを検出します。制限を超えるとデータは削除されます。

// 执行命令
int processCommand(redisClient *c) {
......
// 内存超额
/* Handle the maxmemory directive.
*
* First we try to free some memory if possible (if there are volatile
* keys in the dataset). If there are not the only thing we can do
* is returning an error. */
if (server.maxmemory) {
int retval = freeMemoryIfNeeded();
if ((c->cmd->flags & REDIS_CMD_DENYOOM) && retval == REDIS_ERR) {
flagTransaction(c);
addReply(c, shared.oomerr);
return REDIS_OK;
}
}
......
}
// 如果需要，是否一些内存
int freeMemoryIfNeeded(void) {
size_t mem_used, mem_tofree, mem_freed;
int slaves = listLength(server.slaves);
// redis 从机回复空间和 AOF 内存大小不计算入 redis 内存大小
/* Remove the size of slaves output buffers and AOF buffer from the
* count of used memory. */
mem_used = zmalloc_used_memory();
// 从机回复空间大小
if (slaves) {
listIter li;
listNode *ln;
listRewind(server.slaves,&li);
while((ln = listNext(&li))) {
redisClient *slave = listNodeValue(ln);
unsigned long obuf_bytes = getClientOutputBufferMemoryUsage(slave);
if (obuf_bytes > mem_used)
mem_used = 0;
else
mem_used -= obuf_bytes;
}
}
// server.aof_buf && server.aof_rewrite_buf_blocks
if (server.aof_state != REDIS_AOF_OFF) {
mem_used -= sdslen(server.aof_buf);
mem_used -= aofRewriteBufferSize();
}
// 内存是否超过设置大小
/* Check if we are over the memory limit. */
if (mem_used <= server.maxmemory) return REDIS_OK;
// redis 中可以设置内存超额策略
if (server.maxmemory_policy == REDIS_MAXMEMORY_NO_EVICTION)
return REDIS_ERR; /* We need to free memory, but policy forbids. */
/* Compute how much memory we need to free. */
mem_tofree = mem_used - server.maxmemory;
mem_freed = 0;
while (mem_freed < mem_tofree) {
int j, k, keys_freed = 0;
// 遍历所有数据集
for (j = 0; j < server.dbnum; j++) {
long bestval = 0; /* just to prevent warning */
sds bestkey = NULL;
struct dictEntry *de;
redisDb *db = server.db+j;
dict *dict;
// 不同的策略，选择的数据集不一样
if (server.maxmemory_policy == REDIS_MAXMEMORY_ALLKEYS_LRU ||
server.maxmemory_policy == REDIS_MAXMEMORY_ALLKEYS_RANDOM
{
dict = server.db[j].dict;
} else {
dict = server.db[j].expires;
}
// 数据集为空，继续下一个数据集
if (dictSize(dict) == 0) continue;
// 随机淘汰随机策略：随机挑选
/* volatile-random and allkeys-random policy */
if (server.maxmemory_policy == REDIS_MAXMEMORY_ALLKEYS_RANDOM ||
server.maxmemory_policy == REDIS_MAXMEMORY_VOLATILE_RANDOM)
{
de = dictGetRandomKey(dict);
bestkey = dictGetKey(de);
}
// LRU 策略：挑选最近最少使用的数据
/* volatile-lru and allkeys-lru policy */
else if (server.maxmemory_policy == REDIS_MAXMEMORY_ALLKEYS_LRU ||
server.maxmemory_policy == REDIS_MAXMEMORY_VOLATILE_LRU)
{
// server.maxmemory_samples 为随机挑选键值对次数
// 随机挑选 server.maxmemory_samples个键值对，驱逐最近最少使用的数据
for (k = 0; k < server.maxmemory_samples; k++) {
sds thiskey;
long thisval;
robj *o;
// 随机挑选键值对
de = dictGetRandomKey(dict); 
// 获取键
thiskey = dictGetKey(de); 
/* When policy is volatile-lru we need an additional lookup
* to locate the real key, as dict is set to db->expires. */
if (server.maxmemory_policy == REDIS_MAXMEMORY_VOLATILE_LRU)
de = dictFind(db->dict, thiskey);
o = dictGetVal(de); 
// 计算数据的空闲时间
thisval = estimateObjectIdleTime(o);
// 当前键值空闲时间更长，则记录
/* Higher idle time is better candidate for deletion */
if (bestkey == NULL || thisval > bestval) {
bestkey = thiskey;
bestval = thisval;
}
}
} 
// TTL 策略：挑选将要过期的数据
/* volatile-ttl */
else if (server.maxmemory_policy == REDIS_MAXMEMORY_VOLATILE_TTL) {
// server.maxmemory_samples 为随机挑选键值对次数
// 随机挑选 server.maxmemory_samples个键值对，驱逐最快要过期的数据
for (k = 0; k < server.maxmemory_samples; k++) {
sds thiskey;
long thisval;
de = dictGetRandomKey(dict);
thiskey = dictGetKey(de);
thisval = (long) dictGetVal(de);
/* Expire sooner (minor expire unix timestamp) is better
* candidate for deletion */
if (bestkey == NULL || thisval < bestval) {
bestkey = thiskey;
bestval = thisval;
}
}
}
// 删除选定的键值对
/* Finally remove the selected key. */
if (bestkey) {
long long delta;
robj *keyobj = createStringObject(bestkey,sdslen(bestkey));
// 发布数据更新消息，主要是 AOF 持久化和从机
propagateExpire(db,keyobj);
// 注意， propagateExpire() 可能会导致内存的分配， propagateExpire()
提前执行就是因为 redis 只计算 dbDelete() 释放的内存大小。倘若同时计算 dbDelete() 释放的内存
和 propagateExpire() 分配空间的大小，与此同时假设分配空间大于释放空间，就有可能永远退不出这个循环。
// 下面的代码会同时计算 dbDelete() 释放的内存和 propagateExpire() 分配空间的大小：
// propagateExpire(db,keyobj);
// delta = (long long) zmalloc_used_memory();
// dbDelete(db,keyobj);
// delta -= (long long) zmalloc_used_memory();
// mem_freed += delta;
/////////////////////////////////////////
/* We compute the amount of memory freed by dbDelete() alone.
* It is possible that actually the memory needed to propagate
* the DEL in AOF and replication link is greater than the one
* we are freeing removing the key, but we can&#39;t account for
* that otherwise we would never exit the loop.
*
* AOF and Output buffer memory will be freed eventually so
* we only care about memory used by the key space. */
// 只计算 dbDelete() 释放内存的大小
delta = (long long) zmalloc_used_memory();
dbDelete(db,keyobj);
delta -= (long long) zmalloc_used_memory();
mem_freed += delta;
server.stat_evictedkeys++;
// 将数据的删除通知所有的订阅客户端
notifyKeyspaceEvent(REDIS_NOTIFY_EVICTED, "evicted",
keyobj, db->id);
decrRefCount(keyobj);
keys_freed++; 
// 将从机回复空间中的数据及时发送给从机
/* When the memory to free starts to be big enough, we may
* start spending so much time here that is impossible to
* deliver data to the slaves fast enough, so we force the
* transmission here inside the loop. */
if (slaves) flushSlavesOutputBuffers();
}
} 
// 未能释放空间，且此时 redis 使用的内存大小依旧超额，失败返回
if (!keys_freed) return REDIS_ERR; /* nothing to free... */
}
return REDIS_OK;
}

適用可能なシナリオ

いくつかの戦略の適用可能なシナリオを見てみましょう:

1. allkeys-lru: アプリケーションのキャッシュへのアクセスがべき乗に準拠している場合法則分布 (つまり、比較的ホットなデータがある) またはアプリケーションのキャッシュ アクセス分布がよくわからない場合は、allkeys-lru 戦略を選択できます。

2. allkeys-random: アプリケーションがキャッシュ キーへのアクセス確率が等しい場合、この戦略を使用できます。

3. volatile-ttl: この戦略により、どのキーがエビクションに適しているかを Redis に指示することができます。

さらに、volatile-lru 戦略と volatile-random 戦略は、1 つの Redis インスタンスをキャッシュと永続ストレージの両方に適用する場合に適していますが、2 つの Redis インスタンスを使用して同じ結果を達成することもできます。キーの有効期限を設定すると実際にはより多くのメモリが消費されるため、メモリをより効率的に使用するために allkeys-lru 戦略を使用することをお勧めします。

redis の詳細については、

redis 入門チュートリアル 列に注目してください。

以上がRedis データ削除戦略の詳細な説明の詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。