您现在的位置是:网站首页> 编程资料编程资料
redis 数据删除策略和逐出算法的问题小结_Redis_
2023-05-27
429人已围观
简介 redis 数据删除策略和逐出算法的问题小结_Redis_
数据存储和有效期
在 redis
工作流程中,过期的数据并不需要马上就要执行删除操作。因为这些删不删除只是一种状态表示,可以异步
的去处理,在不忙的时候去把这些不紧急的删除操作做了,从而保证 redis
的高效
数据的存储
在redis中数据的存储不仅仅需要保存数据本身还要保存数据的生命周期,也就是过期时间。在redis 中 数据的存储结构如下图:
获取有效期
Redis是一种内存级数据库,所有数据均存放在内存中,内存中的数据可以通过TTL指令获取其状态
删除策略
在内存占用与CPU占用之间寻找一种平衡,顾此失彼都会造成整体redis性能的下降,甚至引发服务器宕机或内存泄漏。
定时删除
创建一个定时器,当key设置过期时间,且过期时间到达时,由定时器任务立即执行对键的删除操作
优点
节约内存,到时就删除,快速释放掉不必要的内存占用
缺点
CPU压力很大,无论CPU此时负载多高,均占用CPU,会影响redis服务器响应时间和指令吞吐量
总结
用处理器性能换取存储空间
惰性删除
数据到达过期时间,不做处理。等下次访问该数据,如果未过期,返回数据。发现已经过期,删除,返回不存在。这样每次读写数据都需要检测数据是否已经到达过期时间。也就是惰性删除总是在数据的读写时发生的。
expireIfNeeded函数
对所有的读写命令进行检查,检查操作的对象是否过期。过期就删除返回过期,不过期就什么也不做~。
执行数据写入过程中,首先通过expireIfNeeded函数对写入的key进行过期判断。
/* * 为执行写入操作而取出键 key 在数据库 db 中的值。 * * 和 lookupKeyRead 不同,这个函数不会更新服务器的命中/不命中信息。 * * 找到时返回值对象,没找到返回 NULL 。 */ robj *lookupKeyWrite(redisDb *db, robj *key) { // 删除过期键 expireIfNeeded(db,key); // 查找并返回 key 的值对象 return lookupKey(db,key); }
执行数据读取过程中,首先通过expireIfNeeded函数对写入的key进行过期判断。
/* * 为执行读取操作而取出键 key 在数据库 db 中的值。 * * 并根据是否成功找到值,更新服务器的命中/不命中信息。 * * 找到时返回值对象,没找到返回 NULL 。 */ robj *lookupKeyRead(redisDb *db, robj *key) { robj *val; // 检查 key 释放已经过期 expireIfNeeded(db,key); // 从数据库中取出键的值 val = lookupKey(db,key); // 更新命中/不命中信息 if (val == NULL) server.stat_keyspace_misses++; else server.stat_keyspace_hits++; // 返回值 return val; }
执行过期动作expireIfNeeded其实内部做了三件事情,分别是:
- 查看key判断是否过期
- 向slave节点传播执行过期key的动作并发送事件通知
- 删除过期key
/* * 检查 key 是否已经过期,如果是的话,将它从数据库中删除。 * * 返回 0 表示键没有过期时间,或者键未过期。 * * 返回 1 表示键已经因为过期而被删除了。 */ int expireIfNeeded(redisDb *db, robj *key) { // 取出键的过期时间 mstime_t when = getExpire(db,key); mstime_t now; // 没有过期时间 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; // 当服务器运行在 replication 模式时 // 附属节点并不主动删除 key // 它只返回一个逻辑上正确的返回值 // 真正的删除操作要等待主节点发来删除命令时才执行 // 从而保证数据的同步 if (server.masterhost != NULL) return now > when; // 运行到这里,表示键带有过期时间,并且服务器为主节点 /* Return when this key has not expired */ // 如果未过期,返回 0 if (now <= when) return 0; /* Delete the key */ server.stat_expiredkeys++; // 向 AOF 文件和附属节点传播过期信息 propagateExpire(db,key); // 发送事件通知 notifyKeyspaceEvent(REDIS_NOTIFY_EXPIRED, "expired",key,db->id); // 将过期键从数据库中删除 return dbDelete(db,key); }
判断key是否过期的数据结构是db->expires,也就是通过expires的数据结构判断数据是否过期。
内部获取过期时间并返回。
/* * 返回字典中包含键 key 的节点 * * 找到返回节点,找不到返回 NULL * * T = O(1) */ dictEntry *dictFind(dict *d, const void *key) { dictEntry *he; unsigned int h, idx, table; // 字典(的哈希表)为空 if (d->ht[0].size == 0) return NULL; /* We don't have a table at all */ // 如果条件允许的话,进行单步 rehash if (dictIsRehashing(d)) _dictRehashStep(d); // 计算键的哈希值 h = dictHashKey(d, key); // 在字典的哈希表中查找这个键 // T = O(1) for (table = 0; table <= 1; table++) { // 计算索引值 idx = h & d->ht[table].sizemask; // 遍历给定索引上的链表的所有节点,查找 key he = d->ht[table].table[idx]; // T = O(1) while(he) { if (dictCompareKeys(d, key, he->key)) return he; he = he->next; } // 如果程序遍历完 0 号哈希表,仍然没找到指定的键的节点 // 那么程序会检查字典是否在进行 rehash , // 然后才决定是直接返回 NULL ,还是继续查找 1 号哈希表 if (!dictIsRehashing(d)) return NULL; } // 进行到这里时,说明两个哈希表都没找到 return NULL; }
优点
节约CPU性能,发现必须删除的时候才删除。
缺点
内存压力很大,出现长期占用内存的数据。
总结
用存储空间换取处理器性能
定期删除
周期性轮询redis库中时效性数据,采用随机抽取的策略,利用过期数据占比的方式删除频度。
优点
CPU性能占用设置有峰值,检测频度可自定义设置
内存压力不是很大,长期占用内存的冷数据会被持续清理
缺点
需要周期性抽查存储空间
定期删除详解
redis的定期删除是通过定时任务实现的,也就是定时任务会循环调用serverCron
方法。然后定时检查过期数据的方法是databasesCron
。定期删除的一大特点就是考虑了定时删除过期数据会占用cpu时间,所以每次执行databasesCron
的时候会限制cpu的占用不超过25%。真正执行删除的是 activeExpireCycle
方法。
时间事件
对于持续运行的服务器来说, 服务器需要定期对自身的资源和状态进行必要的检查和整理, 从而让服务器维持在一个健康稳定的状态, 这类操作被统称为常规操作(cron job)
在 Redis 中, 常规操作由 redis.c/serverCron()
实现, 它主要执行以下操作
1 更新服务器的各类统计信息,比如时间、内存占用、数据库占用情况等。
2 清理数据库中的过期键值对。
3 对不合理的数据库进行大小调整。
4 关闭和清理连接失效的客户端。
5 尝试进行 AOF 或 RDB 持久化操作。
6 如果服务器是主节点的话,对附属节点进行定期同步。
7 如果处于集群模式的话,对集群进行定期同步和连接测试。
因为 serverCron()
需要在 Redis 服务器运行期间一直定期运行, 所以它是一个循环时间事件: serverCron()
会一直定期执行,直到服务器关闭为止。
在 Redis 2.6 版本中, 程序规定 serverCron()
每秒运行 10
次, 平均每 100
毫秒运行一次。 从 Redis 2.8 开始, 用户可以通过修改 hz
选项来调整 serverCron()
的每秒执行次数, 具体信息请参考 redis.conf
文件中关于 hz
选项的说明
查看hz
way1 : config get hz # "hz" "10" way2 : info server # server.hz 10
serverCron()
serverCron()
会定期的执行,在serverCron()
执行中会调用databasesCron()
方法(serverCron()
还做了其他很多事情,但是现在不讨论,只谈删除策略)
int serverCron(struct aeEventLoop *eventLoop, long long id, void *clientData) { // 略去多无关代码 /* We need to do a few operations on clients asynchronously. */ // 检查客户端,关闭超时客户端,并释放客户端多余的缓冲区 clientsCron(); /* Handle background operations on Redis databases. */ // 对数据库执行各种操作 databasesCron(); /* !我们关注的方法! */
databasesCron()
在 databasesCron()
中 调用了 activeExpireCycle()
方法,来对过期的数据进行处理。(在这里还会做一些其他操作~ 调整数据库大小,主动和渐进式rehash)
// 对数据库执行删除过期键,调整大小,以及主动和渐进式 rehash void databasesCron(void) { // 判断是否是主服务器 如果是 执行主动过期键清除 if (server.active_expire_enabled && server.masterhost == NULL) // 清除模式为 CYCLE_SLOW ,这个模式会尽量多清除过期键 activeExpireCycle(ACTIVE_EXPIRE_CYCLE_SLOW); // 在没有 BGSAVE 或者 BGREWRITEAOF 执行时,对哈希表进行 rehash if (server.rdb_child_pid == -1 && server.aof_child_pid == -1) { static unsigned int resize_db = 0; static unsigned int rehash_db = 0; unsigned int dbs_per_call = REDIS_DBCRON_DBS_PER_CALL; unsigned int j; /* Don't test more DBs than we have. */ // 设定要测试的数据库数量 if (dbs_per_call > server.dbnum) dbs_per_call = server.dbnum; /* Resize */ // 调整字典的大小 for (j = 0; j < dbs_per_call; j++) { tryResizeHashTables(resize_db % server.dbnum); resize_db++; } /* Rehash */ // 对字典进行渐进式 rehash if (server.activerehashing) { for (j = 0; j < dbs_per_call; j++) { int work_done = incrementallyRehash(rehash_db % server.dbnum); rehash_db++; if (work_done) { /* If the function did some work, stop here, we'll do * more at the next cron loop. */ break; } } } } }
activeExpireCycle()
大致流程如下
1 遍历指定个数的db(默认的 16 )进行删除操作
2 针对每个db随机获取过期数据每次遍历不超过指定数量(如20),发现过期数据并进行删除。
3 如果有多于25%的keys过期,重复步骤 2
除了主动淘汰的频率外,Redis对每次淘汰任务执行的最大时长也有一个限定,这样保证了每次主动淘汰不会过多阻塞应用请求,以下是这个限定计算公式:
#define ACTIVE_EXPIRE_CYCLE_SLOW_TIME_PERC 25 /* CPU max % for keys collection */ ``... ``timelimit = 1000000*ACTIVE_EXPIRE_CYCLE_SLOW_TIME_PERC/server.hz/100;
也就是每次执行时间的25%用于过期数据删除。
void activeExpireCycle(int type) { // 静态变量,用来累积函数连续执行时的数据 static unsigned int current_db = 0; /* Last DB tested. */ static int timelimit_exit = 0; /* Time limit hit in previous call? */ static long long last_fast_cycle = 0; /* When last fast cycle ran. */ unsigned int j, iteration = 0; // 默认每次处理的数据库数量 unsigned int dbs_per_call = REDIS_DBCRON_DBS_PER_CALL; // 函数开始的时间 long long start = ustime(), timelimit; // 快速模式 if (type == ACTIVE_EXPIRE_CYCLE_FAST) { // 如果上次函数没有触发 timelimit_exit ,那么不执行处理 if (!timelimit_exit) return; // 如果距离上次执行未够一定时间,那么不执行处理 if (start < last_fast_cycle + ACTIVE_EXPIRE_CYCLE_FAST_DURATION*2) return; // 运行到这里,说明执行快速处理,记录当前时间 last_fast_cycle = start; } /* * 一般情况下,函数只处理 REDIS_DBCRON_DBS_PER_CALL 个数据库, * 除非: * * 1) 当前数据库的数量小于 REDIS_DBCRON_DBS_PER_CALL * 2) 如果上次处理遇到了时间上限,那么这次需要对所有数据库进行扫描, * 这可以避免过多的过期键占用空间 */ if (dbs_per_call > server.dbnum || timelimit_exit) dbs_per_call = server.dbnum; // 函数处理的微秒时间上限 // ACTIVE_EXPIRE_CYCLE_SLOW_TIME_PERC 默认为 25 ,也即是 25 % 的 CPU 时间 timelimit = 1000000*ACTIVE_EXPIRE_CYCLE_SLOW_TIME_PERC/server.hz/100; timelimit_exit = 0; if (timelimit <= 0) timelimit = 1; // 如果是运行在快速模式之下 // 那么最多只能运行 FAST_DURATION 微秒 // 默认值为 1000 (微秒) if (type == ACTIVE_EXPIRE_CYCLE_FAST) timelimit = ACTIVE_EXPIRE_CYCLE_FAST_DURATION; /* in microseconds. */ // 遍历数据库 for (j = 0; j < dbs_per_call; j++) { int expired; // 指向要处理的数据库 redisDb *db = server.db+(current_db % server.dbnum); // 为 DB 计数器加一,如果进入 do 循环之后因为超时而跳出 // 那么下次会直接从下个 DB 开始处理 current_db++; do { unsigned long num, slots; long long now, ttl_sum; int ttl_samples; /* If there is nothing to expire try next DB ASAP. */ // 获取数据库中带过期时间的键的数量 // 如果该数量为 0 ,直接跳过这个数据库 if ((num = dictSize(db->expires)) == 0) { db->avg_ttl = 0; break; } // 获取数据库中键值对的数量 slots = dictSlots(db->expires); // 当前时间 now = mstime(); // 这个数据库的使用率低于 1% ,扫描起来太费力了(大部分都会 MISS) // 跳过,等待字典收缩程序运行 if (num && slots > DICT_HT_INITIAL_SIZE && (num*100/slots < 1)) break; /* * 样本计数器 */ // 已处理过期键计数器 expired = 0; // 键的总 TTL 计数器 ttl_sum = 0; // 总共处理的键计数器 ttl_samples = 0; // 每次最多只能检查 LOOKUPS_PER_LOOP 个键 if (num > ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP) num = ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP; // 开始遍历数据库 while (num--) { dictEntry *de; long long ttl; // 从 expires 中随机取出一个带过期时间的键 if ((de = dictGetRandomKey(d
点击排行
本栏推荐
