Un article pour parler de la stratégie d'expiration dans Redis

Cet article vous présentera la stratégie d'expiration dans Redis et verra comment mettre en œuvre la stratégie de suppression paresseuse et la stratégie de suppression régulière. J'espère qu'il vous sera utile !

Enregistrez le délai d'expiration

Redis peut définir le délai d'expiration pour chaque clé et placera chaque clé avec un délai d'expiration défini dans un dictionnaire indépendant. [Recommandations associées : Tutoriel vidéo Redis]

typedef struct redisDb { 
int id; //id是数据库序号，为0-15(默认Redis有16个数据库) 
long avg_ttl; //存储的数据库对象的平均ttl(time to live)，用于统计 
dict *dict; //存储数据库所有的key-value 
dict *expires; //存储key的过期时间 
dict *blocking_keys;//blpop 存储阻塞key和客户端对象 
dict *ready_keys;//阻塞后push 响应阻塞客户端 存储阻塞后push的key和客户端对象 dict *watched_keys;//存储watch监控的的key和客户端对象 
} redisDb;

dict est utilisé pour conserver toutes les paires clé-valeur contenues dans une base de données Redis, expires est utilisé pour conserver les clés avec des délais d'expiration définis dans une base de données Redis (c'est-à-dire la clé et le mappage des échecs fois). Notez que le délai d'expiration ici est exprimé en horodatages en millisecondes. Par exemple, s'il expire le 02/01/2022 à 22:45:02, la valeur est 1641134702000

Lorsque nous utilisons la commande expire pour définir le délai d'expiration de. une clé, Redis arrive en premier Recherchez dans la table du dictionnaire dict pour voir si la clé à définir existe. Si elle existe, ajoutez la clé et le délai d'expiration à la table du dictionnaire expire.

Lorsque nous utilisons la commande setex pour insérer des données dans le système, Redis ajoute d'abord la clé et la valeur au dict de la table du dictionnaire, puis ajoute la clé et le délai d'expiration à la table du dictionnaire. Notez que setex ne peut être utilisé que pour les chaînes.

Pour faire simple, la clé avec le délai d'expiration défini et le délai d'expiration spécifique sont tous conservés dans la table du dictionnaire des expirations.

Définir le délai d'expiration

Utilisation de expire

La commande expire est utilisée comme suit : expire key ttl (unité secondes)

127.0.0.1:6379> expire name 2 #2秒失效 
(integer) 1 
127.0.0.1:6379> get name 
(nil) 
127.0.0.1:6379> set name zhangfei 
OK 
127.0.0.1:6379> ttl name #永久有效 
(integer) -1 
127.0.0.1:6379> expire name 30 #30秒失效 
(integer) 1 
127.0.0.1:6379> ttl name #还有24秒失效 
(integer) 24 
127.0.0.1:6379> ttl name #失效 
(integer) -2

Redis a quatre commandes différentes qui peuvent être utilisées pour définir le temps de survie de la clé (clé combien de temps peut-elle survivre) ou le délai d'expiration (quand la clé sera-t-elle supprimée) : La commande

expire est utilisée pour définir le temps de survie de la clé sur ttlseconds

la commande pexpire est utilisée pour définir la durée de survie de la clé temps de survie en ttl La commande millisecondes

expireat est utilisée pour définir le délai d'expiration de la clé clé sur l'horodatage secondes spécifié par timestamp. La commande pexpireat est utilisée pour définir le délai d'expiration de la clé clé sur le . millisecondes

horodatage spécifié par timestamp.

Notez que l'implémentation finale de expire, pexpire et expireat est toutes implémentée via pexpireat, ce qui signifie que quelle que soit la commande exécutée par le client, Redis la convertira en commande pexpireat pour l'exécution. Par conséquent, l’heure stockée dans le dictionnaire d’expiration est l’heure d’expiration de la clé représentée par l’horodatage milliseconde.

Politique d'expiration

Si une clé expire, quand sera-t-elle supprimée ?

Il existe trois stratégies d'expiration

Suppression programmée : tout en définissant l'heure d'expiration de la clé, créez une minuterie afin que la minuterie puisse immédiatement effectuer la suppression de la clé lorsque l'heure d'expiration de la clé arrive. (

Créer une suppression par minuterie

)
• Suppression paresseuse : laissez l'expiration de la clé tranquille, mais chaque fois que vous obtenez la clé de l'espace clé, vérifiez si la clé obtenue a expiré, supprimez la clé si ; elle n'a pas expiré, la clé est restituée. (Supprimer lors de l'utilisation
)
• Suppression régulière : de temps en temps, le programme vérifie la base de données et supprime les clés expirées. Il existe des décisions algorithmiques quant au nombre de clés expirées à supprimer et au nombre de bases de données à vérifier. (Analyse et suppression régulières
)
Suppression programmée

Avantages

• 1. Le plus convivial pour la mémoire : en utilisant une minuterie, vous pouvez vous assurer que les clés expirées seront supprimées le plus rapidement possible pour être libérées. la mémoire occupée.

Inconvénients

• 1. Le moins convivial pour le CPU : Lorsqu'il y a de nombreuses clés expirées, la suppression des clés expirées peut prendre une partie considérable du temps CPU, affectant le temps de réponse et le débit du serveur.

Suppression paresseuse

Avantages

• 1. Les clés expirées ne seront vérifiées que lorsque la clé est supprimée, c'est-à-dire que le processeur n'a pas besoin d'analyser régulièrement, et il n'y a pas de vérification. besoin de créer un grand nombre de minuteries.

Inconvénients

• 1. Le moins convivial pour la mémoire : Si une clé a expiré mais ne sera pas consultée ultérieurement, elle restera dans la base de données. S'il y a trop de clés de ce type, cela occupera sans aucun doute beaucoup de mémoire.

Suppression périodique

La suppression périodique est un compromis entre la suppression programmée ci-dessus et la suppression paresseuse.

Avantages

• 1. La suppression périodique effectue une opération de clé d'expiration de temps en temps et réduit l'impact des opérations de suppression sur le temps CPU en limitant la durée et la fréquence des opérations de suppression.

2. En supprimant les clés expirées, le gaspillage de mémoire causé par les clés expirées peut être efficacement réduit. Inconvénients : Il est difficile de déterminer la durée et la fréquence des opérations de suppression. 1. Si les opérations de suppression sont effectuées trop fréquemment, ou si l'heure. est trop longue, la stratégie de suppression régulière dégénérera en suppression planifiée, ce qui prendra trop de temps d'exécution CPU.

2. Si l'opération de suppression prend trop peu de temps, ou si le temps d'exécution est trop court, la stratégie de suppression normale sera la même que la suppression paresseuse, entraînant une perte de mémoire.

Stratégie d'expiration de Redis

Redis utilise deux stratégies : suppression paresseuse et suppression régulière : en utilisant ces deux stratégies, le serveur peut trouver un bon équilibre entre l'utilisation rationnelle du temps CPU et éviter le gaspillage d'espace mémoire. équilibre.

Implémentation d'une stratégie de suppression paresseuse

Suppression paresseuse des clés expirées La stratégie de suppression est implémentée par la fonction db.c/expireIfNeeded Toutes les commandes Redis qui lisent et écrivent dans la base de données appelleront la fonction expireIfNeed pour vérifier l'entrée. clé avant l'exécution :

• Si la clé a expiré, alors la fonction expireIfNeeded supprimera la clé
• Si la clé n'a pas expiré, alors la fonction expireIfNeeded ne fera pas l'opération

Le processus d'appel de la fonction expireIfNeeded par la commande est comme indiqué ci-dessous

De plus, comme chaque clé accessible peut être supprimée, chaque commande doit donc être capable de gérer à la fois la présence et l'absence de la clé. La figure suivante montre le processus d'exécution de la commande get

Mise en œuvre d'une stratégie de suppression régulière

La stratégie de suppression régulière des clés expirées est implémentée par la fonction redis.c/activeExpireCycle, chaque fois que le serveur Redis est périodiquement fonctionne redis.c Lorsque la fonction /serverCron est exécutée, la fonction activeExpireCycle sera appelée, qui parcourt chaque base de données du serveur plusieurs fois dans un délai spécifié.

Redis effectue 10 analyses d'expiration par seconde par défaut. Les analyses d'expiration ne parcourent pas toutes les clés du dictionnaire d'expiration, mais adoptent une stratégie gourmande simple.

(1) Sélectionnez au hasard 20 clés dans le dictionnaire expiré.

(2) Supprimez les clés expirées parmi ces 20 clés.

(3) Si la proportion de clés expirées dépasse 1/4, répétez l'étape (1). Dans le même temps, afin de garantir que l'analyse expirée n'effectue pas un cycle excessif et ne provoque pas le gel du processus, l'algorithme augmente également la limite supérieure du temps d'analyse, qui ne dépassera pas 25 ms par défaut.

Supposons que toutes les clés d'une grande instance Redis expirent en même temps, que se passera-t-il ?

Consommation du processeur

Redis continuera à analyser le dictionnaire expiré (cycle plusieurs fois) jusqu'à ce que le dictionnaire expiré expire. s'arrêter lorsque les clés deviennent rares (le nombre de cycles diminue considérablement).

Entraînant un retard ou un délai d'attente de la demande

Lorsque la demande du client arrive, si le serveur entre dans l'état d'analyse expiré, la demande du client attendra au moins 25 ms avant d'être traitée si le client définit le délai d'attente relativement court. , comme 10 ms, alors un grand nombre de connexions seront fermées en raison d'un délai d'attente, et de nombreuses exceptions se produiront du côté commercial

Assurez-vous donc de faire attention au délai d'expiration si un grand nombre de clés expirent, définissez-le. une plage aléatoire pour le délai d'expiration et ne peuvent pas tous expirer en même temps.

Pour plus de connaissances sur la programmation, veuillez visiter : Introduction à la programmation ! !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!