Parlons des avantages et des fonctionnalités de Redis

Cet article vous apporte des connaissances pertinentes sur Redis, qui présente principalement certains avantages et caractéristiques de Redis est un open source écrit en langage ANSI C, est conforme au protocole BSD, prend en charge le réseau et peut être basé sur la mémoire. base de données de stockage distribué, jetons-y un coup d'œil, j'espère qu'elle sera utile à tout le monde.

Apprentissage recommandé : Tutoriel vidéo Redis

Qu'est-ce que redis

Remote DIctionary Server (Redis) est un système de stockage clé-valeur écrit par Salvatore Sanfilippo, qui est une base de données non relationnelle multiplateforme.

Redis est une base de données de stockage de valeurs-clés open source écrite en langage ANSI C, conforme au protocole BSD, prenant en charge la persistance réseau, basée sur la mémoire, distribuée et facultative, et fournit des API dans plusieurs langues.

Redis est souvent appelé serveur de structure de données car les valeurs peuvent être de types tels que String, Hash, List, Sets et Sorted Sets.

Caractéristiques de Redis :

• Base de données en mémoire, rapide, prend également en charge la persistance des données. Les données en mémoire peuvent être enregistrées sur le disque et peuvent être chargées à nouveau pour être utilisées lors du redémarrage.
• Redis prend non seulement en charge les données simples de type clé-valeur, mais fournit également le stockage de structures de données telles que liste, ensemble, zset, hachage, etc.
• Redis prend en charge la sauvegarde des données, c'est-à-dire la sauvegarde des données en mode maître-esclave.
• Transactions de support

Avantages de Redis :

• Performances extrêmement élevées – Redis peut lire à une vitesse de 110 000 fois/s et écrire à une vitesse de 81 000 fois/s.
• Types de données riches – Redis prend en charge les opérations de type de données Chaînes, Listes, Hachages, Ensembles et Ensembles ordonnés pour les cas binaires.
• Atomique - Toutes les opérations de Redis sont atomiques, et Redis prend également en charge l'exécution atomique après la fusion de plusieurs opérations. (Transaction)
• Fonctionnalités riches – Redis prend également en charge la publication/abonnement, les notifications, l'expiration des clés et d'autres fonctionnalités.

En quoi Redis est-il différent des autres magasins à valeur clé ?

• Redis a des structures de données plus complexes et fournit des opérations atomiques sur celles-ci. Il s'agit d'un chemin évolutif différent des autres bases de données. Les types de données de Redis sont basés sur des structures de données de base et sont transparents pour les programmeurs, sans nécessiter d'abstractions supplémentaires.
• Redis s'exécute en mémoire mais peut être conservé sur le disque, la mémoire doit donc être pesée lors de la lecture et de l'écriture à grande vitesse de différents ensembles de données, car la quantité de données ne peut pas être supérieure à la mémoire matérielle. Un autre avantage des bases de données en mémoire est que par rapport aux mêmes structures de données complexes sur disque, le fonctionnement en mémoire est très simple, donc Redis peut faire beaucoup de choses avec une forte complexité interne. De plus, en termes de format de disque, ils sont générés de manière compacte car ils ne nécessitent pas d'accès aléatoire.

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 et Redis peut conserver ses données
2. Type de prise en charge des données memcached Toutes les valeurs sont de simples chaînes En remplacement, Redis prend en charge des types de données plus riches, fournissant list, set et zset , hash et. d'autres structures de données sont stockées à l'aide de différents modèles sous-jacents. Les méthodes de mise en œuvre sous-jacentes et les 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.
3. Les tailles des valeurs sont différentes : Redis peut atteindre un maximum de 512 Mo ; le cache mémoire ne fait que 1 Mo.
4. Redis est beaucoup plus rapide que memcached
5. Redis prend en charge la sauvegarde des données, c'est-à-dire la sauvegarde des données en mode maître-esclave.
6. Pourquoi Redis est-il si rapide ? 1. Entièrement basées sur la mémoire, la plupart des requêtes sont des opérations de mémoire pure, très rapides. Les données sont stockées en mémoire, comme HashMap. L'avantage de HashMap est que la complexité temporelle de la recherche et de l'opération est O(1) ; La structure de Redis est spécialement conçue

3. L'utilisation d'un seul thread évite les changements de contexte inutiles et les conditions de concurrence. Il n'y a pas de commutation causée par un multi-processus ou un multi-thread qui consomme le processeur. Il n'est pas nécessaire de prendre en compte divers problèmes de verrouillage et. il n'y a pas de déverrouillage, pas de consommation de performances causée par un éventuel blocage ;

4. Utilisez un modèle de multiplexage d'E/S multicanal, des E/S non bloquantes ;

5. les différences entre eux Les protocoles d'application pour la communication entre les clients sont différents. Redis construit directement son propre mécanisme 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. modèle de multiplexage d'E/S de canal

Le modèle de multiplexage d'E/S multicanal utilise select, poll et epoll pour surveiller les événements d'E/S de plusieurs flux en même temps. Lorsqu'il est inactif, le thread actuel sera bloqué lorsqu'un ou plusieurs flux ont un problème. Un événement d'E/S se produit, il sort de l'état de blocage, de sorte que le programme interrogera tous les flux (epoll interroge uniquement les flux qui ont réellement émis l'événement) et ne traitera que les flux prêts en séquence. Cette approche évite beaucoup de choses. d'opérations inutiles.

**Ici, « multiple » fait référence à plusieurs connexions réseau et « réutilisation » fait référence à la réutilisation du même fil. **L'utilisation de la technologie de multiplexage d'E/S multicanal permet à un seul thread de gérer efficacement plusieurs demandes de connexion (minimisant la consommation de temps des E/S réseau), et Redis exploite les données en mémoire très rapidement, ce qui signifie que l'opération en mémoire sera ne deviendra pas un goulot d'étranglement affectant les performances de Redis. Les points ci-dessus contribuent principalement au débit élevé de Redis.

Alors pourquoi Redis est-il monothread ?

Nous devons d'abord comprendre que toutes les analyses ci-dessus visent à créer une atmosphère où Redis est rapide ! La FAQ officielle indique que, étant donné que Redis est une opération basée sur la mémoire, le processeur n'est pas le goulot d'étranglement de Redis. Le goulot d'étranglement de Redis est probablement la taille de la mémoire de la machine ou la bande passante du réseau. Étant donné que le monothreading est facile à mettre en œuvre et que le CPU ne deviendra pas un goulot d'étranglement, il est logique d'adopter une solution monothread (après tout, utiliser le multi-threading causera beaucoup de problèmes !).

Types de données et commandes Redis

1. String (String)

redis 127.0.0.1:6379> SET rediskey redis
OK
redis 127.0.0.1:6379> GET rediskey
"redis"

2 Hash (Hash)

Le hachage Redis est un mappage de champ de type chaîne (champ) et de valeur (valeur) de tables et de hachages. sont particulièrement adaptés au stockage d'objets.

Chaque hachage dans Redis peut stocker 232 - 1 paires clé-valeur (plus de 4 milliards)

3. Liste (Liste)

La liste Redis est une simple liste de chaînes, triées par ordre d'insertion. Vous pouvez ajouter un élément en tête (à gauche) ou en queue (à droite) de la liste

Une liste peut contenir jusqu'à 232 - 1 éléments (4294967295, plus de 4 milliards d'éléments par liste).

redis 127.0.0.1:6379> LPUSH rediskey redis
(integer) 1
redis 127.0.0.1:6379> LPUSH rediskey mongodb
(integer) 2
redis 127.0.0.1:6379> LPUSH rediskey mysql
(integer) 3
redis 127.0.0.1:6379> LRANGE rediskey 0 10

1) "mysql"
2) "mongodb"
3) "redis"

4. Set

Redis' Set est une collection non ordonnée de type String. Les membres de l'ensemble sont uniques, ce qui signifie que les données en double ne peuvent pas apparaître dans l'ensemble.

L'encodage de l'objet de collection peut être un entier ou une table de hachage.

Les collections dans Redis sont implémentées via des tables de hachage, donc la complexité de l'ajout, de la suppression et de la recherche est O(1).

Le nombre maximum de membres dans une collection est de 232 - 1 (4294967295, chaque collection peut stocker plus de 4 milliards de membres).

redis 127.0.0.1:6379> SADD rediskey redis
(integer) 1
redis 127.0.0.1:6379> SADD rediskey mongodb
(integer) 1
redis 127.0.0.1:6379> SADD rediskey mysql
(integer) 1
redis 127.0.0.1:6379> SADD rediskey mysql
(integer) 0
redis 127.0.0.1:6379> SMEMBERS rediskey

1) "mysql"
2) "mongodb"
3) "redis"

5. Ensemble trié (ensemble trié)

L'ensemble ordonné Redis, comme un ensemble, est également une collection d'éléments de type chaîne et n'autorise pas les membres en double.

La différence est que chaque élément est associé à une partition de type double. Redis utilise des scores pour trier les membres de la collection du plus petit au plus grand.

Les membres d'un ensemble ordonné sont uniques, mais les scores peuvent être répétés.

Les ensembles sont implémentés via des tables de hachage, donc la complexité de l'ajout, de la suppression et de la recherche est O(1). Le nombre maximum de membres dans une collection est de 232 - 1 (4294967295, chaque collection peut stocker plus de 4 milliards de membres).

6 HyperLogLog

Redis a ajouté la structure HyperLogLog dans la version 2.8.9.

Redis HyperLogLog est un algorithme utilisé pour les statistiques de cardinalité. L'avantage de HyperLogLog est que lorsque le nombre ou le volume des éléments d'entrée est très grand, l'espace requis pour calculer la cardinalité est toujours fixe et très petit.

Dans Redis, chaque clé HyperLogLog ne coûte que 12 Ko de mémoire pour calculer la cardinalité de près de 2^64 éléments différents. Cela contraste fortement avec une collection qui consomme plus de mémoire lors du calcul de la cardinalité. Plus il y a d'éléments, plus la mémoire est consommée.

Cependant, comme HyperLogLog calculera uniquement la cardinalité en fonction des éléments d'entrée et ne stockera pas les éléments d'entrée eux-mêmes, HyperLogLog ne peut pas renvoyer chaque élément de l'entrée comme une collection.

Qu'est-ce qu'une cardinalité ?

Par exemple, l'ensemble de données {1, 3, 5, 7, 5, 7, 8}, alors l'ensemble de cardinalité de cet ensemble de données est {1, 3, 5,7, 8}, la cardinalité (éléments non répétitifs) est 5. L'estimation de la cardinalité consiste à calculer rapidement la cardinalité dans la plage d'erreur acceptable.

Exemple

L'exemple suivant démontre le processus de fonctionnement d'HyperLogLog :

//添加指定元素到 HyperLogLog 中。
redis 127.0.0.1:6379> PFADD rediskey "redis" 

1) (integer) 1

redis 127.0.0.1:6379> PFADD rediskey "mongodb"

1) (integer) 1

redis 127.0.0.1:6379> PFADD rediskey "mysql"

1) (integer) 1
//添加指定元素到 HyperLogLog 中。
redis 127.0.0.1:6379> PFCOUNT rediskey

(integer) 3

7 Publier et s'abonner

Redis publier et s'abonner (pub/sub) est un modèle de communication par message : l'expéditeur (pub) envoie un message, le abonné (sous) ) pour recevoir des messages.

Les clients Redis peuvent s'abonner à n'importe quel nombre de chaînes.

La figure suivante montre la relation entre le canal canal1 et les trois clients abonnés à ce canal - client2, client5 et client1 :

Exemple

L'exemple suivant montre comment fonctionnent la publication et l'abonnement, deux redis-cli les clients doivent être ouverts.

Dans notre exemple, nous avons créé une chaîne d'abonnement nommée runoobChat :

第一个 redis-cli 客户端

redis 127.0.0.1:6379> SUBSCRIBE runoobChat

Reading messages... (press Ctrl-C to quit)
1) "subscribe"
2) "runoobChat"
3) (integer) 1

现在，我们先重新开启个 redis 客户端，然后在同一个频道 runoobChat 发布两次消息，订阅者就能接收到消息。

第二个 redis-cli 客户端

redis 127.0.0.1:6379> PUBLISH runoobChat "Redis PUBLISH test"
(integer) 1

redis 127.0.0.1:6379> PUBLISH runoobChat "Learn redis by runoob.com"
(integer) 1

# 订阅者的客户端会显示如下消息
 1) "message"
2) "runoobChat"
3) "Redis PUBLISH test"
 1) "message"
2) "runoobChat"
3) "Learn redis by runoob.com"

gif 演示如下：

• 开启本地 Redis 服务，开启两个 redis-cli 客户端。
• 在第一个 redis-cli 客户端输入 SUBSCRIBE runoobChat，意思是订阅 runoobChat 频道。
• 在第二个 redis-cli 客户端输入 PUBLISH runoobChat “Redis PUBLISH test” 往 runoobChat 频道发送消息，这个时候在第一个 redis-cli 客户端就会看到由第二个 redis-cli 客户端发送的测试消息。

8. 事务

Redis 事务可以一次执行多个命令， 并且带有以下三个重要的保证：

• 批量操作在发送 EXEC 命令前被放入队列缓存。
• 收到 EXEC 命令后进入事务执行，事务中任意命令执行失败，其余的命令依然被执行。
• 在事务执行过程，其他客户端提交的命令请求不会插入到事务执行命令序列中。

一个事务从开始到执行会经历以下三个阶段：

• 开始事务。
• 命令入队。
• 执行事务。

实例

以下是一个事务的例子， 它先以 MULTI 开始一个事务， 然后将多个命令入队到事务中， 最后由 EXEC 命令触发事务， 一并执行事务中的所有命令：

redis 127.0.0.1:6379> MULTI
OK

redis 127.0.0.1:6379> SET book-name "Mastering C++ in 21 days"
QUEUED

redis 127.0.0.1:6379> GET book-name
QUEUED

redis 127.0.0.1:6379> SADD tag "C++" "Programming" "Mastering Series"
QUEUED

redis 127.0.0.1:6379> SMEMBERS tag
QUEUED

redis 127.0.0.1:6379> EXEC
1) OK
2) "Mastering C++ in 21 days"
3) (integer) 3
4) 1) "Mastering Series"
   2) "C++"
   3) "Programming"

单个 Redis 命令的执行是原子性的，但 Redis 没有在事务上增加任何维持原子性的机制，所以 Redis 事务的执行并不是原子性的。

事务可以理解为一个打包的批量执行脚本，但批量指令并非原子化的操作，中间某条指令的失败不会导致前面已做指令的回滚，也不会造成后续的指令不做。

这是官网上的说明 From redis docs on transactions:

It’s important to note that even when a command fails, all the other commands in the queue are processed – Redis will not stop the processing of commands.

比如：

redis 127.0.0.1:7000> multi
OK
redis 127.0.0.1:7000> set a aaa
QUEUED
redis 127.0.0.1:7000> set b bbb
QUEUED
redis 127.0.0.1:7000> set c ccc
QUEUED
redis 127.0.0.1:7000> exec
1) OK
2) OK
3) OK

如果在 set b bbb 处失败，set a 已成功不会回滚，set c 还会继续执行。

9. 脚本

Redis 脚本使用 Lua 解释器来执行脚本。 Redis 2.6 版本通过内嵌支持 Lua 环境。执行脚本的常用命令为 EVAL。

redis 127.0.0.1:6379> EVAL "return {KEYS[1],KEYS[2],ARGV[1],ARGV[2]}" 2 key1 key2 first second

1) "key1"
2) "key2"
3) "first"
4) "second"

10 GEO

Redis GEO 主要用于存储地理位置信息，并对存储的信息进行操作，该功能在 Redis 3.2 版本新增。

Redis GEO 操作方法有：

• geoadd：添加地理位置的坐标。
• geopos：获取地理位置的坐标。
• geodist：计算两个位置之间的距离。
• georadius：根据用户给定的经纬度坐标来获取指定范围内的地理位置集合。
• georadiusbymember：根据储存在位置集合里面的某个地点获取指定范围内的地理位置集合。
• geohash：返回一个或多个位置对象的 geohash 值。

redis> GEOADD Sicily 13.361389 38.115556 "Palermo" 15.087269 37.502669 "Catania"
(integer) 2
redis> GEODIST Sicily Palermo Catania
"166274.1516"
redis> GEORADIUS Sicily 15 37 100 km
1) "Catania"
redis> GEORADIUS Sicily 15 37 200 km
1) "Palermo"
2) "Catania"
redis>

11 Redis Stream

Redis Stream 是 Redis 5.0 版本新增加的数据结构。

Redis Stream 主要用于消息队列（MQ，Message Queue），Redis 本身是有一个 Redis 发布订阅 (pub/sub) 来实现消息队列的功能，但它有个缺点就是消息无法持久化，如果出现网络断开、Redis 宕机等，消息就会被丢弃。

简单来说发布订阅 (pub/sub) 可以分发消息，但无法记录历史消息。

而 Redis Stream 提供了消息的持久化和主备复制功能，可以让任何客户端访问任何时刻的数据，并且能记住每一个客户端的访问位置，还能保证消息不丢失。

Redis Stream 的结构如下所示，它有一个消息链表，将所有加入的消息都串起来，每个消息都有一个唯一的 ID 和对应的内容：

每个 Stream 都有唯一的名称，它就是 Redis 的 key，在我们首次使用 xadd 指令追加消息时自动创建。

上图解析：

• Consumer Group : Groupe de consommateurs, créé à l'aide de la commande XGROUP CREATE. Un groupe de consommateurs comporte plusieurs consommateurs (Consumers).
• last_delivered_id : Curseur Chaque groupe de consommateurs aura un curseur last_delivered_id. Tout consommateur lisant le message déplacera le curseur last_delivered_id vers l'avant.
• ending_ids : La variable d'état du consommateur, qui est utilisée pour conserver l'identifiant non confirmé du consommateur. ending_ids enregistre les messages qui ont été lus par le client mais qui n'ont pas encore reçu d'accusé de réception (caractère d'accusé de réception).

Redis Pipeline Technology

Redis est un service TCP basé sur le modèle client-serveur et le protocole de requête/réponse. Cela signifie qu'une requête suivra généralement les étapes suivantes :

• Le client envoie une requête de requête au serveur et écoute le retour du Socket, généralement en mode blocage, en attendant que le serveur réponde.
• Le serveur traite la commande et renvoie le résultat au client.

---

Technologie de pipeline Redis

La technologie de pipeline Redis permet au client de continuer à envoyer des requêtes au serveur lorsque le serveur ne répond pas, et éventuellement de lire les réponses de tous les serveurs en même temps.

Apprentissage recommandé : Tutoriel vidéo Redis

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!