Résumé des questions d'entretien Redis, apprenons-en

C'est à nouveau la période de pointe du recrutement du printemps et des changements d'emploi. Tous les programmeurs sont-ils incapables de supporter l'idée de taper du code et de commencer à s'orienter vers une augmentation de salaire ? Aujourd'hui, je vais résumer pour vous les questions de l'entretien Redis !

Recommandation spéciale : Questions d'entretien Redis 2020 (dernières)

1. redis?

Redis est une base de données clé-valeur hautes performances basée sur la mémoire. (Recommandation 1 : Tutoriel vidéo Redis) (Recommandation 2 : Tutoriel MySQL)

2. Fonctionnalités de Reids　

Redis est essentiellement une base de données en mémoire de type clé-valeur, un peu comme memcached. L'intégralité de la base de données est chargée dans la mémoire pour fonctionner, et les données de la base de données sont vidées sur le disque dur pour être stockées via des opérations asynchrones à intervalles réguliers. Parce qu'il s'agit d'une opération de mémoire pure, Redis offre d'excellentes performances et peut gérer plus de 100 000 opérations de lecture et d'écriture par seconde. Il s'agit de la base de données clé-valeur la plus rapide connue.

L'excellence de Redis n'est pas seulement la performance. Le plus grand charme de Redis est qu'il prend en charge la sauvegarde d'une variété de structures de données. De plus, la limite maximale d'une seule valeur est de 1 Go, contrairement à Memcached, qui ne peut le faire. économisez 1 Mo de données, Redis peut Il est utilisé pour implémenter de nombreuses fonctions utiles, telles que l'utilisation de sa liste pour créer une liste FIFO doublement liée, l'implémentation d'un service de file d'attente de messages léger et hautes performances et l'utilisation de son ensemble pour créer une balise hautes performances. système, etc De plus, Redis peut également définir le délai d'expiration de la valeur-clé stockée, de sorte qu'elle peut également être utilisée comme version améliorée de memcached.

Le principal inconvénient de Redis est que la capacité de la base de données est limitée par la mémoire physique et ne peut pas être utilisée pour une lecture et une écriture hautes performances de données massives. Par conséquent, les scénarios adaptés à Redis se limitent principalement aux hautes performances. opérations et calculs de petites quantités de données.

3. Quels sont les avantages de l'utilisation de Redis ? 　

(1) C'est rapide car les données sont stockées en mémoire, similaire à HashMap. L'avantage de HashMap est que la complexité temporelle de la recherche et de l'opération est O(1)

(2) Prend en charge les types de données riches, prend en charge les chaînes, les listes, les ensembles, les ensembles triés, le hachage

(3) Prend en charge les transactions, les opérations sont atomiques. La soi-disant atomicité signifie que toutes les modifications apportées aux données sont soit. exécuté ou non. Non exécuté

(4) Fonctionnalités riches : peut être utilisé pour la mise en cache, la messagerie, la définition du délai d'expiration par clé, il sera automatiquement supprimé après l'expiration

4. Quels sont les avantages de Redis par rapport à Memcached Advantage ? 　

(1) Toutes les valeurs dans memcached sont des chaînes simples En remplacement, redis prend en charge des types de données plus riches

(2) redis est plus rapide que memcached Beaucoup plus rapide (3) redis peut conserver ses données

5. Quelles sont les différences entre Memcache et Redis ?

1). Méthode de stockage Memecache stocke toutes les données dans la mémoire. Il raccrochera après une panne de courant. Les données ne peuvent pas dépasser la taille de la mémoire. Une partie de Redis est stockée sur le disque dur, ce qui garantit la persistance des données.

2) Types de support de données Memcache prend en charge des types de données relativement simples. Redis a des types de données complexes.

3). Les modèles sous-jacents utilisés sont différents. Leurs méthodes de mise en œuvre sous-jacentes et leurs protocoles d'application pour la communication avec les clients sont différents. Redis a directement construit son propre mécanisme de VM, car si le système général appelle les fonctions système, il perdra un certain temps à se déplacer et à demander.

6. Problèmes de performances courants et solutions de Redis : 　

1).Master écrit un instantané de mémoire et la commande save planifie la fonction rdbSave, ce qui bloquera le travail du thread principal. Lorsque l'instantané est relativement volumineux, l'impact sur les performances est très important et le service sera suspendu par intermittence, il est donc préférable que le maître n'écrive pas d'instantanés de mémoire.

2) Maîtrisez la persistance AOF. Si le fichier AOF n'est pas réécrit, cette méthode de persistance aura un impact minimal sur les performances, mais le fichier AOF continuera à croître si le fichier AOF est trop volumineux. affecter la récupération de la vitesse de redémarrage du maître. Il est préférable de ne pas effectuer de travail de persistance sur le maître, y compris les instantanés de mémoire et les fichiers journaux AOF. En particulier, n'activez pas les instantanés de mémoire pour la persistance. Si les données sont critiques, un esclave doit activer les données de sauvegarde AOF, et la stratégie est la suivante. pour synchroniser une fois par seconde.

3) Le maître appelle BGREWRITEAOF pour réécrire le fichier AOF qui occupera une grande quantité de ressources CPU et mémoire pendant la réécriture, ce qui entraînera une charge de service excessive et une suspension du service à court terme.

4). Problèmes de performances de la réplication maître-esclave Redis Pour la vitesse de réplication maître-esclave et la stabilité de la connexion, il est préférable que l'esclave et le maître soient dans le même LAN

7. Il y a 20 millions de données dans MySQL, mais seulement 200 000 données sont stockées dans Redis. Comment s'assurer que les données dans Redis sont des données chaudes

Connaissances connexes : Quand la taille. Si l'ensemble de données de la mémoire Redis augmente jusqu'à une certaine taille, il mettra en œuvre une stratégie d'obsolescence des données (stratégie de recyclage). redis propose 6 stratégies d'élimination des données :

volatile-lru : sélectionnez les données les moins récemment utilisées dans l'ensemble de données (server.db[i].expires) avec un délai d'expiration défini pour l'élimination

volatile-ttl : sélectionnez les données qui expireront dans l'ensemble de données (server.db[i].expires) qui a défini un délai d'expiration à éliminer

volatile-random : sélectionnez aléatoirement les données à éliminer de l'ensemble de données (server.db[i].expires) avec un délai d'expiration défini

allkeys-lru : à partir de l'ensemble de données (server.db[i]. ] .dict) et éliminez les données les moins récemment utilisées

allkeys-random : sélectionnez arbitrairement les données dans l'ensemble de données (server.db[i].dict) pour éliminer

no-enviction ( expulsion ) : Il est interdit d'expulser des données

8. Veuillez utiliser Redis et n'importe quel langage pour implémenter un code de protection de connexion malveillant, limitant chaque ID utilisateur à un maximum de 5 connexions en une heure. Pour des fonctions ou fonctions de connexion spécifiques, utilisez simplement une fonction vide et il n'est pas nécessaire de les écrire en détail.

9. Pourquoi Redis doit-il mettre toutes les données en mémoire

Afin d'obtenir la vitesse de lecture et d'écriture la plus rapide, Redis lit toutes les données ? mémoire et écrit les données sur le disque de manière asynchrone. Redis présente donc les caractéristiques d'une vitesse rapide et d'une persistance des données. Si les données ne sont pas placées en mémoire, la vitesse des E/S du disque affectera sérieusement les performances de Redis. Aujourd'hui, alors que la mémoire devient de moins en moins chère, Redis deviendra de plus en plus populaire.

Si la mémoire maximale utilisée est définie, de nouvelles valeurs ne peuvent pas être insérées une fois que le nombre d'enregistrements de données atteint la limite de mémoire.

10.Redis est à processus unique et à thread unique

redis utilise la technologie de file d'attente pour transformer l'accès simultané en accès série, éliminant ainsi la surcharge du contrôle série de base de données traditionnel

11. Comment résoudre le problème de concurrence concurrentielle de Redis ?

Redis est un mode mono-thread à processus unique, utilisant le mode file d'attente pour transformer l'accès simultané en accès série. . Redis lui-même n'a aucune notion de verrous. Redis n'est pas en concurrence pour plusieurs connexions client. Cependant, lorsque le client Jedis accède simultanément à Redis, des problèmes tels que l'expiration du délai de connexion, les erreurs de conversion de données, le blocage et la fermeture de la connexion par le client peuvent survenir. sont tous causés par

en raison d'une confusion de connexion client. Il existe 2 solutions à cela :

1. Du point de vue du client, afin d'assurer une communication normale et ordonnée avec Redis entre chaque client, les connexions sont mutualisées, et en même temps, le client lit et écrit. Opérations Redis Le verrou interne est synchronisé.

2. Du point de vue du serveur, utilisez setnx pour implémenter le verrouillage.

Remarque : Pour le premier type, l'application doit gérer elle-même la synchronisation des ressources. La méthode qui peut être utilisée est relativement populaire, vous pouvez utiliser synchronisé ou verrouillé. Le deuxième type nécessite l'utilisation de Redis. setnx, mais cela nécessite de prêter attention à certains problèmes.

12. Comprendre CAS (opération de vérification et de définition pour implémenter le verrouillage optimiste) dans Redis ?

Comme beaucoup d'autres bases de données, Redis est également fourni sous forme de base de données NoSQL. mécanisme de transaction. Dans Redis, les quatre commandes MULTI/EXEC/DISCARD/WATCH sont la pierre angulaire de notre implémentation de transactions. Je pense que ce concept n'est pas étranger aux développeurs ayant une expérience en développement de bases de données relationnelles. Néanmoins, nous énumérerons brièvement les caractéristiques d'implémentation des transactions dans Redis :

1). Dans les transactions, toutes les commandes seront exécutées en série et séquentiellement. Pendant l'exécution de la transaction, Redis ne fournira aucun service pour les autres demandes des clients, garantissant ainsi que toutes les commandes de la transaction sont exécutées de manière atomique.

2). Par rapport aux transactions dans les bases de données relationnelles, si une commande ne s'exécute pas dans une transaction Redis, les commandes suivantes continueront à être exécutées.

3). Nous pouvons démarrer une transaction via la commande MULTI, que les personnes ayant de l'expérience dans le développement de bases de données relationnelles peuvent comprendre comme l'instruction "BEGIN TRANSACTION". Les commandes exécutées après cette instruction seront considérées comme des opérations au sein de la transaction. Enfin, nous pouvons valider/annuler toutes les opérations au sein de la transaction en exécutant la commande EXEC/DISCARD. Ces deux commandes Redis peuvent être considérées comme équivalentes à l'instruction COMMIT/ROLLBACK dans une base de données relationnelle.

4). Avant le démarrage de la transaction, s'il y a un échec de communication entre le client et le serveur et que le réseau est déconnecté, toutes les instructions ultérieures à exécuter ne seront pas exécutées par le serveur. Cependant, si l'événement d'interruption du réseau se produit après que le client a exécuté la commande EXEC, toutes les commandes de la transaction seront exécutées par le serveur.

5). Lors de l'utilisation du mode Append-Only, Redis écrira toutes les opérations d'écriture de la transaction sur le disque lors de cet appel en appelant la fonction système write. Cependant, si une panne du système se produit pendant le processus d'écriture, telle qu'un temps d'arrêt provoqué par une panne de courant, seule une partie des données peut être écrite sur le disque à ce moment-là, tandis qu'une autre partie des données est perdue.

Le serveur Redis effectuera une série de contrôles de cohérence nécessaires lors du redémarrage. Une fois qu'un problème similaire est détecté, il se fermera immédiatement et affichera une invite d'erreur correspondante. À l'heure actuelle, nous devons utiliser pleinement l'outil redis-check-aof fourni dans la boîte à outils Redis. Cet outil peut nous aider à localiser les erreurs d'incohérence des données et à restaurer certaines des données écrites. Après la réparation, nous pouvons redémarrer le serveur Redis.

13.Commande WATCH et verrouillage optimiste basé sur CAS :

Dans les transactions Redis, la commande WATCH peut être utilisée pour fournir la fonctionnalité CAS (check-and-set) . Supposons que nous surveillons plusieurs clés via la commande WATCH avant l'exécution de la transaction. Si la valeur d'une clé change après WATCH, la transaction exécutée par la commande EXEC sera abandonnée et une réponse multi-bulk Null sera renvoyée pour informer l'appelant. de la transaction

L'exécution a échoué. Par exemple, nous supposons encore que la commande incr n'est pas fournie dans Redis pour compléter l'incrément atomique des valeurs clés. Si nous voulons implémenter cette fonction, nous ne pouvons écrire que nous-mêmes le code correspondant. Le pseudo code est le suivant :

val = GET mykey
val = val + 1
SET mykey $val

Le code ci-dessus ne peut garantir que le résultat de l'exécution est correct que dans le cas d'une seule connexion, car s'il y a plusieurs clients exécutant ce code en même temps, puis un scénario d'erreur qui se produit souvent dans les programmes multithread se produira - une condition de concurrence critique. Par exemple, les clients A et B lisent la valeur originale de mykey en même temps. Supposons que la valeur soit 10. Après cela, les deux clients en ajoutent un à la valeur et la redéfinissent sur le serveur Redis. de mykey à perdre. Le résultat est 11, pas 12 comme nous le pensions. Afin de résoudre des problèmes similaires, nous avons besoin de l'aide de la commande WATCH, voir le code suivant :

WATCH mykey
val = GET mykey
val = val + 1
MULTI
SET mykey $val
EXEC

La différence avec le code précédent est que le nouveau code surveille la clé via la commande WATCH avant d'obtenir la valeur de mykey , puis entourez la commande set dans une transaction, ce qui peut effectivement garantir qu'avant d'exécuter EXEC pour chaque connexion, si la valeur de mykey obtenue par la connexion actuelle est modifiée par d'autres clients connectés, la commande EXEC du courant la connexion ne parviendra pas à s'exécuter. De cette façon, l'appelant peut savoir si val a été réinitialisé avec succès après avoir jugé la valeur de retour.

14. Plusieurs façons de persistance Redis

1. Snapshots

Par défaut, Redis stocke les instantanés de données Dans le fichier binaire sur le disque, le fichier. le nom est dump.rdb. Vous pouvez configurer la stratégie de persistance de Redis. Par exemple, s'il y a plus de M mises à jour dans l'ensemble de données toutes les N secondes, les données seront écrites sur le disque ou vous pouvez appeler manuellement la commande SAVE ou BGSAVE ;

Principe de fonctionnement

. Fourches Redis.

． Le processus enfant commence à écrire des données dans le fichier RDB temporaire.

． Lorsque le processus enfant a fini d'écrire le fichier RDB, remplacez l'ancien fichier par le nouveau fichier.

． Cette méthode permet à Redis d'utiliser la technologie de copie sur écriture.

2. AOF

Le mode instantané n'est pas très robuste lorsque le système s'arrête ou que Redis est accidentellement tué, les dernières données écrites sur Redis seront perdues. Ce n'est peut-être pas un gros problème pour certaines applications, mais pour les applications qui nécessitent une grande fiabilité,

Redis n'est pas un choix approprié.

Le mode fichier Ajouter uniquement est une autre option.

Vous pouvez activer le mode AOF dans le fichier de configuration

3. Méthode de mémoire virtuelle

Lorsque votre clé est petite et la valeur est grande, l'effet de l'utilisation de la VM sera être meilleur Bien. Parce que la mémoire enregistrée de cette manière est relativement grande

Lorsque votre clé n'est pas petite, vous pouvez envisager d'utiliser des méthodes extraordinaires pour transformer une grande clé en une grande valeur. envisagez de combiner la clé et la valeur. dans une nouvelle valeur.

vm-max-threads Ce paramètre peut définir le nombre de threads pour accéder au fichier d'échange. Il est préférable de ne pas dépasser le nombre de cœurs de la machine. S'il est défini sur 0, alors tous les accès au fichier d'échange. Les opérations sont toutes en série. Cela peut entraîner un long délai, mais l'intégrité des données est bien garantie

Lorsque je l'ai testé moi-même, j'ai constaté que. les performances d'utilisation de la mémoire virtuelle sont également bonnes. Si la quantité de données est importante, vous pouvez envisager des bases de données distribuées ou autres

15. La stratégie d'invalidation du cache et le mécanisme d'invalidation de clé primaire de Redis

En tant que système de cache, ils doivent être régulièrement nettoyées et invalidées. Les données nécessitent une stratégie d'invalidation et d'élimination de clé primaire

Dans Redis, les clés avec une durée de vie sont dites volatiles. Lors de la création d'un cache, définissez la durée de vie d'une clé donnée. Lorsque la clé expire (la durée de vie est 0), elle peut être supprimée.

1. Certaines opérations qui affectent le temps de survie

Le temps de survie peut être supprimé en utilisant la commande DEL pour supprimer la clé entière, ou les données d'origine peuvent être écrasées par SET et GETSET. commandes, c'est-à-dire qu'après avoir modifié la valeur correspondant à la clé et l'avoir écrasée avec la même clé et la même valeur, le temps de survie des données actuelles est différent.

Par exemple, exécuter la commande INCR sur une clé, exécuter la commande LPUSH sur une liste, ou exécuter la commande HSET sur une table de hachage, ces opérations ne modifieront pas le temps de survie de la clé elle-même. En revanche, si vous utilisez RENAME pour renommer une clé, le temps de survie de la clé renommée sera le même qu'avant le renommage.

Une autre possibilité de la commande RENAME est d'essayer de renommer une clé avec un temps de survie en another_key avec un temps de survie. À ce moment, l'ancienne another_key (et son temps de survie) sera supprimée, puis La. l'ancienne clé sera renommée another_key, donc la durée de survie de la nouvelle another_key est la même que celle de la clé d'origine. Utilisez la commande PERSIST pour supprimer la durée de vie de la clé sans supprimer la clé, ce qui fait de la clé une clé persistante.

2. Comment mettre à jour le temps de survie

Vous pouvez exécuter la commande EXPIRE sur une clé qui a déjà un temps de survie, et le nouveau temps de survie spécifié remplacera l'ancien temps de survie. La précision du délai d'expiration a été contrôlée dans un délai de 1 ms et la complexité temporelle de l'échec de la clé primaire est O(1) La commande

EXPIRE est utilisée avec la commande TTL pour afficher le temps de survie actuel. de la clé. Renvoie 1 si le réglage réussit ; renvoie 0 lorsque la clé n'existe pas ou que le temps de survie ne peut pas être défini pour la clé.

Configuration maximale du cache

Dans Redis, les utilisateurs sont autorisés à définir la taille maximale de la mémoire

server.maxmemory

默认为0，没有指定最大缓存，如果有新的数据添加，超过最大内存，则会使redis崩溃，所以一定要设置。redis 内存数据集大小上升到一定大小的时候，就会实行数据淘汰策略。

redis 提供 6种数据淘汰策略：

． volatile-lru：从已设置过期时间的数据集（server.db[i].expires）中挑选最近最少使用的数据淘汰

． volatile-ttl：从已设置过期时间的数据集（server.db[i].expires）中挑选将要过期的数据淘汰

． volatile-random：从已设置过期时间的数据集（server.db[i].expires）中任意选择数据淘汰

． allkeys-lru：从数据集（server.db[i].dict）中挑选最近最少使用的数据淘汰

． allkeys-random：从数据集（server.db[i].dict）中任意选择数据淘汰

． no-enviction（驱逐）：禁止驱逐数据

注意这里的6种机制，volatile和allkeys规定了是对已设置过期时间的数据集淘汰数据还是从全部数据集淘汰数据，后面的lru、ttl以及random是三种不同的淘汰策略，再加上一种no-enviction永不回收的策略。

使用策略规则：

1、如果数据呈现幂律分布，也就是一部分数据访问频率高，一部分数据访问频率低，则使用allkeys-lru

2、如果数据呈现平等分布，也就是所有的数据访问频率都相同，则使用allkeys-random

三种数据淘汰策略：

ttl和random比较容易理解，实现也会比较简单。主要是Lru最近最少使用淘汰策略，设计上会对key 按失效时间排序，然后取最先失效的key进行淘汰

16.redis 最适合的场景　　

Redis最适合所有数据in-momory的场景，虽然Redis也提供持久化功能，但实际更多的是一个disk-backed的功能，跟传统意义上的持久化有比较大的差别，那么可能大家就会有疑问，似乎Redis更像一个加强版的Memcached，那么何时使用Memcached,何时使用Redis呢?

如果简单地比较Redis与Memcached的区别，大多数都会得到以下观点：

1 、Redis不仅仅支持简单的k/v类型的数据，同时还提供list，set，zset，hash等数据结构的存储。

2 、Redis支持数据的备份，即master-slave模式的数据备份。

3 、Redis支持数据的持久化，可以将内存中的数据保持在磁盘中，重启的时候可以再次加载进行使用。

（1）、会话缓存（Session Cache）

最常用的一种使用Redis的情景是会话缓存（session cache）。用Redis缓存会话比其他存储（如Memcached）的优势在于：Redis提供持久化。当维护一个不是严格要求一致性的缓存时，如果用户的购物车信息全部丢失，大部分人都会不高兴的，现在，他们还会这样吗？

幸运的是，随着 Redis 这些年的改进，很容易找到怎么恰当的使用Redis来缓存会话的文档。甚至广为人知的商业平台Magento也提供Redis的插件。

（2）、全页缓存（FPC）

除基本的会话token之外，Redis还提供很简便的FPC平台。回到一致性问题，即使重启了Redis实例，因为有磁盘的持久化，用户也不会看到页面加载速度的下降，这是一个极大改进，类似PHP本地FPC。

再次以Magento为例，Magento提供一个插件来使用Redis作为全页缓存后端。

此外，对WordPress的用户来说，Pantheon有一个非常好的插件 wp-redis，这个插件能帮助你以最快速度加载你曾浏览过的页面。

（3）、队列

Reids在内存存储引擎领域的一大优点是提供 list 和 set 操作，这使得Redis能作为一个很好的消息队列平台来使用。Redis作为队列使用的操作，就类似于本地程序语言（如Python）对 list 的 push/pop 操作。

如果你快速的在Google中搜索“Redis queues”，你马上就能找到大量的开源项目，这些项目的目的就是利用Redis创建非常好的后端工具，以满足各种队列需求。例如，Celery有一个后台就是使用Redis作为broker，你可以从这里去查看。

（4），排行榜/计数器

Redis在内存中对数字进行递增或递减的操作实现的非常好。集合（Set）和有序集合（Sorted Set）也使得我们在执行这些操作的时候变的非常简单，Redis只是正好提供了这两种数据结构。所以，我们要从排序集合中获取到排名最靠前的10个用户–我们称之为“user_scores”，我们只需要像下面一样执行即可：

当然，这是假定你是根据你用户的分数做递增的排序。如果你想返回用户及用户的分数，你需要这样执行：

ZRANGE user_scores 0 10 WITHSCORES

Agora Games就是一个很好的例子，用Ruby实现的，它的排行榜就是使用Redis来存储数据的，你可以在这里看到。

（5）、发布/订阅

最后（但肯定不是最不重要的）是Redis的发布/订阅功能。发布/订阅的使用场景确实非常多。我已看见人们在社交网络连接中使用，还可作为基于发布/订阅的脚本触发器，甚至用Redis的发布/订阅功能来建立聊天系统！（不，这是真的，你可以去核实）。

Redis提供的所有特性中，我感觉这个是喜欢的人最少的一个，虽然它为用户提供如果此多功能。

相关推荐：

《Redis教程》

《2020年前端vue面试题大汇总（附答案）》