Rumah > Artikel > pangkalan data > Artikel untuk bercakap tentang operasi tamat tempoh dan strategi tamat tempoh dalam Redis
Artikel ini akan membawa anda memahami operasi tamat tempoh dan strategi tamat tempoh dalam Redis, memperkenalkan empat kaedah menetapkan masa tamat tempoh dalam Redis, kunci tamat tempoh dalam kegigihan, proses pelaksanaan kunci tamat tempoh, dll. Saya harap ia akan membantu semua orang .
Jika tiada konsep tamat tempoh dalam Redis
, ini bermakna semua kunci yang kita tulis akan sentiasa disimpan dalam Redis
selagi ia tidak aktif dipadamkan. Dan Redis
ialah pangkalan data berasaskan memori, dan ruang memori adalah sangat terhad. [Cadangan berkaitan: Tutorial video Redis]
Tetapan tamat tempoh
Redis
Terdapat empat cara utama untuk menetapkan masa tamat tempoh:
expire key seconds
: Tetapkan key
untuk tamat tempoh selepas n saat. pexpire key milliseconds
: Tetapkan key
untuk tamat tempoh dalam n milisaat. expireat key timestamp
: Tetapkan key
untuk tamat tempoh selepas cap masa tertentu (tepat hingga saat). pexpireat key millisecondsTimestamp
: Menetapkan key
untuk tamat tempoh selepas cap masa tertentu (tepat hingga milisaat). Anda boleh menggunakan perintah ttl key
(dalam saat) atau pttl key
(dalam milisaat) untuk melihat berapa lama key
akan tamat tempoh.
Redis
Anda boleh menggunakan perintah time
untuk menanyakan cap masa masa semasa (tepat hingga saat).
Beberapa kaedah untuk mengendalikan masa tamat secara langsung dalam rentetan, seperti yang disenaraikan di bawah:
set key value ex seconds
: Tetapkan pasangan nilai kunci dan nyatakan masa tamat tempoh (tepat hingga saat). set key value px milliseconds
: Tetapkan pasangan nilai kunci dan tentukan masa tamat tempoh (tepat hingga milisaat). setex key seconds valule
: Tetapkan pasangan nilai kunci dan tentukan masa tamat tempoh (tepat hingga saat). Alih keluar masa tamat tempoh
Gunakan arahan: persist key
untuk mengalih keluar masa tamat tempoh nilai kunci. -1 bermakna tidak pernah tamat tempoh.
Pelaksanaan Java operasi tamat tempoh
Gunakan Jedis
untuk melaksanakan operasi Redis
, kod:
public class TTLTest { public static void main(String[] args) throws InterruptedException { // 创建 Redis 连接 Jedis jedis = new Jedis("xxx.xxx.xxx.xxx", 6379); // 设置 Redis 密码(如果没有密码,此行可省略) jedis.auth("xxx"); // 存储键值对(默认情况下永不过期) jedis.set("k", "v"); // 查询 TTL(过期时间) Long ttl = jedis.ttl("k"); // 打印过期日志 // 过期时间:-1 System.out.println("过期时间:" + ttl); // 设置 100s 后过期 jedis.expire("k", 100); // 等待 1s 后执行 Thread.sleep(1000); // 打印过期日志 // 执行 expire 后的 TTL=99 System.out.println("执行 expire 后的 TTL=" + jedis.ttl("k")); } }
Lagi kaedah operasi tamat tempoh, seperti yang disenaraikan di bawah:
pexpire(String key, long milliseconds)
: Tetapkan tamat tempoh selepas n milisaat. expireAt(String key, long unixTime)
: Tamat tempoh selepas cap masa tertentu (tepat hingga saat). pexpireAt(String key, long millisecondsTimestamp)
: Tamat tempoh selepas cap masa tertentu (tepat hingga milisaat). persist(String key)
: Alih keluar masa tamat tempoh. public class TTLTest { public static void main(String[] args) throws InterruptedException { // 创建 Redis 连接 Jedis jedis = new Jedis("xxx.xxx.xxx.xxx", 6379); // 设置 Redis 密码(如果没有密码,此行可省略) jedis.auth("xxx"); // 存储键值对(默认情况下永不过期) jedis.set("k", "v"); // 查询 TTL(过期时间) Long ttl = jedis.ttl("k"); // 打印过期日志 System.out.println("过期时间:" + ttl); // 设置 100s 后过期 jedis.expire("k", 100); // 等待 1s 后执行 Thread.sleep(1000); // 打印过期日志 System.out.println("执行 expire 后的 TTL=" + jedis.ttl("k")); // 设置 n 毫秒后过期 jedis.pexpire("k", 100000); // 设置某个时间戳后过期(精确到秒) jedis.expireAt("k", 1573468990); // 设置某个时间戳后过期(精确到毫秒) jedis.pexpireAt("k", 1573468990000L); // 移除过期时间 jedis.persist("k"); } }
Kunci tamat tempoh dalam ketekunan
RDB
Fail dibahagikan kepada dua peringkat, RDB
peringkat penjanaan fail dan peringkat pemuatan.
1. Penjanaan fail RDB
RDB
pemuatan dibahagikan kepada dua situasi berikut:
Redis
ialah Dalam mod pengendalian pelayan utama, apabila memuatkan fail RDB
, atur cara akan menyemak kekunci yang disimpan dalam fail, dan kunci tamat tempoh tidak akan dimuatkan ke dalam pangkalan data. Oleh itu, kunci tamat tempoh tidak akan menjejaskan pelayan utama memuatkan fail RDB
Redis
ialah hamba mod jalankan pelayan, apabila memuatkan fail RDB
, The kunci akan dimuatkan ke dalam pangkalan data tidak kira sama ada ia telah tamat tempoh. Tetapi memandangkan pelayan tuan dan hamba sedang menyegerakkan data, data pelayan hamba akan dikosongkan . Jadi secara umumnya, kunci tamat tempoh tidak akan menjejaskan pelayan hamba memuatkan fail RDB
. RDB
Kod sumber untuk memuatkan fail boleh didapati dalam fungsi rdb.c
fail rdbLoad()
Kod sumber adalah seperti berikut:
/* Check if the key already expired. This function is used when loading * an RDB file from disk, either at startup, or when an RDB was * received from the master. In the latter case, the master is * responsible for key expiry. If we would expire keys here, the * snapshot taken by the master may not be reflected on the slave. * * 如果服务器为主节点的话, * 那么在键已经过期的时候,不再将它们关联到数据库中去 */ if (server.masterhost == NULL && expiretime != -1 && expiretime < now) { decrRefCount(key); decrRefCount(val); // 跳过 continue; }
1 penulisan fail AOF
Apabila Redis
berterusan dalam mod AOF
, jika kunci tamat tempoh masuk. pangkalan data belum Jika dipadamkan, fail AOF
akan mengekalkan kunci tamat tempoh Apabila kunci tamat tempoh dipadamkan, Redis
akan menambahkan perintah AOF
pada fail DEL
untuk memadamkan nilai kunci secara eksplisit.
2. AOF menulis semula
Apabila melakukan AOF
menulis semula, pasangan nilai kunci dalam Redi
s akan ditandakan kekunci tamat tempoh fail AOF
yang ditulis semula, jadi ia tidak akan memberi sebarang kesan pada AOF
penulisan semula.
Kunci tamat tempoh perpustakaan tuan-hamba
当 Redis
运行在主从模式下时,从库不会进行过期扫描,从库对过期的处理是被动的。也就是即使从库中的 key
过期了,如果有客户端访问从库时,依然可以得到 key
对应的值,像未过期的键值对一样返回。
从库的过期键处理依靠主服务器控制,主库在 key
到期时,会在 AOF
文件里增加一条 del
指令,同步到所有的从库,从库通过执行这条 del
指令来删除过期的 key
。
在
Redis
中我们可以给一些元素设置过期时间,那当它过期之后Redis
是如何处理这些过期键呢?
过期键执行流程
Redis
之所以能知道那些键值过期,是因为在 Redis
中维护了一个字典,存储了所有设置了过期时间的键值,我们称之为过期字典。
过期键源码分析
过期键存储在 redisDb
结构中,源代码在 src/server.h
文件中(基于 Redis 5
):
/* Redis database representation. There are multiple databases identified * by integers from 0 (the default database) up to the max configured * database. The database number is the 'id' field in the structure. */ 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
高负载的情况下或有大量过期键需要同时处理时,会造成 Redis
服务器卡顿,影响主业务执行。不主动删除过期键,每次从数据库获取键值时判断是否过期,如果过期则删除键值,并返回 null。
源码解析
惰性删除的源码位于 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
方法判断键值是否过期,过期则会从数据库中删除,反之则不做任何处理。
每隔一段时间检查一次数据库,随机删除一些过期键。
Redis
默认每秒进行 10
次过期扫描,此配置可通过 Redis
的配置文件 redis.conf 进行配置,配置键为 hz
它的默认值是 hz 10
。
注意:Redis
每次扫描并不是遍历过期字典中的所有键,而是采用随机抽取判断并删除过期键的形式执行的。
定期删除流程
从过期字典中随机取出 20 个键。
删除这 20 个键中过期的键。
如果过期 key
的比例超过 25%,重复步骤 1。
同时为了保证过期扫描不会出现循环过度,导致线程卡死现象,算法还增加了扫描时间的上限,默认不会超过 25ms。
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
使用的是惰性删除加定期删除的过期策略。
更多编程相关知识,请访问:编程入门!!
Atas ialah kandungan terperinci Artikel untuk bercakap tentang operasi tamat tempoh dan strategi tamat tempoh dalam Redis. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!