Quelles sont les situations de blocage de Redis ?

Blocage des commandes

L'utilisation de commandes inappropriées provoque le blocage du client :

• keys * : Obtenez toutes les opérations clés

• Hgetall : Renvoie la somme de tous les champs de la table de hachage

• smembers ; dans la collection ;

La complexité temporelle de ces commandes est O(n), et parfois la table entière est analysée à mesure que n augmente, la consommation de temps augmente et le client est bloqué.

Blocage de la SAVE

Tout le monde sait que lorsque Redis prend un instantané RDB, il appellera la fonction système fork() pour créer un thread enfant pour terminer l'écriture des fichiers temporaires, et la condition de déclenchement est la sauvegarde de la configuration dans le fichier de configuration. .

Lorsque notre configuration est atteinte, la commande bgsave sera déclenchée pour créer un instantané. Cette méthode ne bloquera pas le thread principal, tandis que l'exécution manuelle de la commande save sera exécutée dans le thread principal, bloquant le thread principal.

Persistance synchrone

Lorsque Redis enregistre directement les journaux AOF, s'il y a un grand nombre d'opérations d'écriture et est configuré pour la persistance synchrone

appendfsync always

C'est-à-dire que chaque fois qu'un changement de données se produit, il sera immédiatement enregistré sur le disque, parce que l'écriture sur le disque prend du temps, de mauvaises performances, donc parfois cela bloque le thread principal.

AOF rewrite

• fork crée un sous-thread pour réécrire le fichier Lors de l'exécution de la commande BGREWRITEAOF, le serveur Redis maintiendra un tampon de réécriture AOF, qui sera stocké dans le sous-thread. thread Pendant que le thread crée un nouveau fichier AOF, toutes les commandes d'écriture exécutées par le serveur sont enregistrées.

  BGREWRITEAOF 命令时，Redis 服务器会维护一个 AOF 重写缓冲区，该缓冲区会在子线程创建新 AOF 文件期间，记录服务器执行的所有写命令。

• 当子线程完成创建新 AOF 文件的工作之后，服务器会将重写缓冲区中的所有内容追加到新 AOF 文件的末尾，使得新的 AOF 文件保存的数据库状态与现有的数据库状态一致。

• 最后，服务器用新的 AOF 文件替换旧的 AOF 文件，以此来完成 AOF 文件重写操作。

阻塞就是出现在第2步的过程中，将缓冲区中新数据写到新文件的过程中会产生阻塞。

AOF 日志

AOF 的日志记录不像关系型数据库那样在执行命令之前记录日志（方便故障恢复），而是采用先执行命令后记录日志的方式。

原因就是 AOF 记录日志是不会对命令进行语法检查的，这样就能减少额外的检查开销，不会对当前命令的执行产生阻塞，但可能会给下一个操作带来阻塞风险。

这是因为 AOF 日志也是在主线程中执行的，如果在把日志文件写入磁盘时，磁盘写压力大，就会导致写盘很慢，进而导致后续的操作也无法执行了。

大 Key 问题

大 key 并不是指 key 的值很大，而是 key 对应的 value 很大。

大 key 造成的阻塞问题如下：

• 客户端超时阻塞：由于 Redis 执行命令是单线程处理，然后在操作大 key 时会比较耗时，那么就会阻塞 Redis，从客户端这一视角看，就是很久很久都没有响应。

• 引发网络阻塞：每次获取大 key 产生的网络流量较大，如果一个 key 的大小是 1 MB，每秒访问量为 1000，那么每秒会产生 1000MB 的流量，这对于普通千兆网卡的服务器来说是灾难性的。

• 阻塞工作线程：如果使用 del 删除大 key 时，会阻塞工作线程，这样就没办法处理后续的命令。

查找大 key

当我们在使用 Redis 自带的 --bigkeysLorsque le thread enfant termine le travail de création d'un nouveau fichier AOF, le serveur ajoutera tout le contenu du tampon de réécriture à la fin du nouveau fichier AOF, de sorte que l'état de la base de données enregistré dans le nouveau fichier AOF soit cohérent avec l'état de la base de données existante cohérent.

• Enfin, le serveur remplace l'ancien fichier AOF par le nouveau fichier AOF pour terminer l'opération de réécriture du fichier AOF.

• Le blocage se produit à l'étape 2. Lors de l'écriture de nouvelles données dans le tampon dans un nouveau fichier, un

  blocage
se produira.
• Journal AOF
  La journalisation AOF n'enregistre pas les journaux avant d'exécuter des commandes comme les bases de données relationnelles (pour faciliter la récupération des erreurs), mais utilise la méthode consistant à exécuter d'abord les commandes, puis à enregistrer les journaux.
• La raison en est que la journalisation AOF n'effectue pas de vérification de syntaxe sur les commandes, ce qui peut réduire la surcharge de vérification supplémentaire et ne bloquera pas l'exécution de la commande en cours, mais peut entraîner des risques de blocage pour l'opération suivante.

Cela est dû au fait que le journal AOF est également exécuté dans le thread principal
Si la pression d'écriture sur le disque est élevée lors de l'écriture du fichier journal sur le disque, l'écriture sur le disque sera très lente et les opérations ultérieures seront ralenties. ne sera pas exécuté.

Problème de grande clé

Une grande clé ne signifie pas que la valeur de la clé est très grande, mais que la valeur correspondant à la clé est très grande.

Les problèmes de blocage causés par les grandes clés sont les suivants : Blocage du délai d'expiration du client : étant donné que les commandes d'exécution de Redis sont monothread, l'utilisation de grandes clés prendra plus de temps, ce qui bloquera Redis depuis le client. côté À en juger par la perspective, il n'y a pas de réponse pendant très, très longtemps.

Provoque une congestion du réseau : Chaque fois que vous obtenez une clé volumineuse, le trafic réseau est important. Si la taille d'une clé est de 1 Mo et le nombre de visites par seconde est de 1 000, alors 1 000 Mo de trafic seront générés par seconde. . C'est pour le Gigabit ordinaire. La carte réseau est désastreuse pour le serveur.

Blocage du thread de travail : si vous utilisez del pour supprimer une clé volumineuse, le thread de travail sera bloqué, rendant impossible le traitement des commandes suivantes. 🎜🎜🎜

Trouver de grosses clés

🎜Lorsque nous utilisons le paramètre --bigkeys fourni avec Redis pour trouver de grosses clés, il est préférable d'exécuter la commande sur le nœud esclave, car lorsqu'il est exécuté sur le nœud maître, il 🎜bloquer🎜le nœud maître. 🎜🎜🎜🎜Nous pouvons également utiliser la commande SCAN pour trouver les grosses clés 🎜🎜🎜🎜Afin d'identifier les grosses clés, vous devez d'abord vous assurer que Redis utilise la persistance RDB et analyser le fichier RDB correspondant. Il existe des outils prêts à l'emploi sur Internet : 🎜🎜🎜🎜🎜redis-rdb-tools : un outil écrit en langage Python pour analyser les fichiers instantanés Redis RDB🎜🎜🎜🎜Cet outil s'appelle rdb_bigkeys, qui est écrit en langage Go et peut être utilisé Analyser les fichiers instantanés Redis RDB avec des performances plus élevées. 🎜🎜🎜🎜🎜Supprimer une grande clé🎜🎜L'essence de l'opération de suppression est de libérer l'espace mémoire occupé par la paire clé-valeur. 🎜🎜La libération de mémoire n'est que la première étape. Afin de gérer plus efficacement l'espace mémoire, lorsque l'application libère de la mémoire, 🎜le système d'exploitation doit insérer le bloc de mémoire libéré dans une liste chaînée de blocs de mémoire libres🎜 pour une gestion et une réallocation ultérieures. . Ce processus lui-même prend un certain temps et va 🎜bloquer🎜l'application libérant actuellement de la mémoire. 🎜🎜Ainsi, si une grande quantité de mémoire est libérée en même temps, le temps de fonctionnement de la liste chaînée des blocs de mémoire libres augmentera, ce qui entraînera en conséquence le blocage du 🎜thread principal de Redis🎜 Si le thread principal est bloqué, tout. d'autres requêtes peuvent expirer. De plus en plus, cela entraînera l'épuisement de la connexion Redis et produira diverses exceptions. 🎜🎜🎜Lors de la suppression de clés volumineuses, il est recommandé d'utiliser la suppression par lots et la suppression asynchrone. 🎜

Effacer la base de données

Effacer la base de données revient à supprimer bigkey ci-dessus et flushall implique également la suppression et la libération de toutes les paires clé-valeur, qui sont également les points de blocage de Redis.

Extension du cluster

Le cluster Redis peut étendre et réduire dynamiquement les nœuds. Ce processus est actuellement dans un état semi-automatique et nécessite une intervention manuelle.

Pendant l'expansion et la contraction, la migration des données est nécessaire. Afin d'assurer la cohérence de la migration, Redis toutes les opérations de migration sont des opérations synchrones.

Lors de la migration, Redis aux deux extrémités entrera dans un état de blocage de longueurs variables. Pour les petites clés, ce temps peut être ignoré, mais si l'utilisation de la mémoire de la clé est trop importante, dans les cas graves, cela entraînera. un problème au sein du cluster, provoquant une commutation inutile.

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!