Introduction aux fonctionnalités avancées de Redis

Redis (Remote Dictionary Server), le service de dictionnaire distant, est une base de données clé-valeur open source de type journal et fournit des API dans plusieurs langues.

(Partage de vidéos d'apprentissage : Tutoriel vidéo Redis)

1. Modèle de publication et d'abonnement Redis

En plus de fournir des files d'attente de messages comme une liste, Redis mode, et fournit également un ensemble de commandes pour implémenter le mode publication/abonnement. Par exemple, Weibo, les comptes publics, etc. peuvent tous être réalisés grâce à cela.

1.2 Canal d'abonnement

L'éditeur doit envoyer le message à un endroit où les abonnés peuvent s'abonner au message. Cet endroit est la chaîne. Les abonnés peuvent s'abonner à une ou plusieurs chaînes, et tous les abonnés à cette chaîne recevront ce message.

Ouvrir deux clients pour les tests

客户端1 订阅channel1
127.0.0.1:6379> subscribe channel1
Reading messages... (press Ctrl-C to quit)
1) "subscribe"
2) "channel1"
3) (integer) 1

客户端2 发布一则消息
127.0.0.1:6379> publish channel1 test
(integer) 1

客户端1 订阅消息
127.0.0.1:6379> subscribe channel1
Reading messages... (press Ctrl-C to quit)
1) "subscribe"
2) "channel1"
3) (integer) 1
1) "message"
2) "channel1"
3) "test"

1.2 Abonnez-vous selon les règles

Supporté ? et * espaces réservés. ? représente un caractère, * représente 0 ou plusieurs caractères.

Démarrez quatre redis-cli, un en tant qu'éditeur de messages et les trois autres en tant qu'abonnés.
Abonné 1 : Abonnez-vous aux sports liés

psubscribe *sport

Abonné 2 : Abonnez-vous aux actualités liées

psubscribe news*

Abonné 3 : Abonnez-vous aux liées à la météo

psubscribe new weather*

Éditeur :

publish news-sport Kobe
publish news-music jaychou
publish news-weather rain

A ce moment, l'abonné 1 recevra Kobe, l'abonné 2 recevra toutes les informations et l'abonné 3 recevra la pluie.

2.redis transaction

2.1 Pourquoi utiliser transaction

Nous savons tous qu'une seule commande de redis est atomique, mais si vous Si vous devez utiliser plusieurs commandes comme une séquence d'opérations indissociable, vous devez utiliser des transactions.
Par exemple, en utilisant setnx pour implémenter des verrous distribués, nous définissons généralement d'abord, puis définissons expire sur la clé pour empêcher le verrouillage d'être libéré lorsqu'une exception se produit dans del. Une fois l'entreprise traitée, nous voulons ces trois opérations. à utiliser comme un ensemble de commandes dans del.
Les transactions Redis ont deux caractéristiques :

• L'exécution dans l'ordre d'entrée dans la file d'attente

• ne sera pas affectée par les autres demandes des clients

La conception des transactions de Redis comporte quatre commandes : multi (démarrer la transaction), exec (exécuter la transaction), dicard (annuler la transaction), watch (surveiller)

2.2 Utilisation des transactions

Les scénarios de transfert A et B ont chacun 100 yuans, A transfère 10 yuans à B, A réduit 10 yuans et B ajoute 10 yuans

127.0.0.1:6379> set A 100
OK
127.0.0.1:6379> set B 100
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379> decrby A 10
QUEUED
127.0.0.1:6379> incrby B 10
QUEUED
127.0.0.1:6379> exec
1) (integer) 90
2) (integer) 110
127.0.0.1:6379> get A
"90"
127.0.0.1:6379> get B
"110"

Ouvrez la transaction via la commande multiple. Les transactions ne peuvent pas être imbriquées. Plusieurs commandes multi ont le même effet
Après avoir utilisé multi pour démarrer une transaction, le client envoie plusieurs commandes au serveur. Ces commandes ne seront pas exécutées immédiatement, mais seront placées dans une file d'attente. La commande exec est appelée, les commandes de la file d'attente seront exécutées.
Nous pouvons utiliser la suppression pour vider la file d'attente des transactions.

127.0.0.1:6379> multi
OK
127.0.0.1:6379> set k1 1
QUEUED
127.0.0.1:6379> set k2 2
QUEUED
127.0.0.1:6379> discard
OK
127.0.0.1:6379> get k1
(nil)
127.0.0.1:6379> get k2
(nil)

Lorsqu'il y a un problème lors de l'exécution de la transaction, sera-t-elle annulée ?

Une erreur s'est produite avant l'exécution (telle qu'une erreur de syntaxe de commande)

127.0.0.1:6379> clear
127.0.0.1:6379> multi
OK
127.0.0.1:6379> set name test
QUEUED
127.0.0.1:6379> hset user lisi
(error) ERR wrong number of arguments for 'hset' command
127.0.0.1:6379> exec
(error) EXECABORT Transaction discarded because of previous errors.
127.0.0.1:6379> get name
(nil)

Une erreur s'est produite après l'exécution (en utilisant des commandes de types de données différents pour la même clé)

127.0.0.1:6379> multi
OK
127.0.0.1:6379> set k1 1
QUEUED
127.0.0.1:6379> hset k1 a b
QUEUED
127.0.0.1:6379> exec
1) OK
2) (error) WRONGTYPE Operation against a key holding the wrong kind of value
127.0.0.1:6379> get k1
"1"

Par les opérations ci-dessus, nous pouvons savoir que lorsqu'une erreur se produit dans une transaction avant l'exécution, toutes les opérations seront annulées si une erreur se produit après l'exécution, seule la mauvaise commande ne sera pas exécutée ;
Pourquoi Redis ne revient-il pas en arrière lorsqu'il y a une erreur dans une transaction ?
Nous pouvons voir à partir de l'opération ci-dessus que redis n'annule que lorsque la syntaxe de l'instruction est incorrecte et que les erreurs d'opération d'instruction sont des bogues causés par les développeurs. Par exemple : vous donnez +1 à un type int, puis accidentellement + 2. Ou +. 1 un type de chaîne, le rollback n'est pas applicable

2.3 commande watch

Elle peut fournir une opération de verrouillage optimiste CAS pour les transactions Redis, c'est-à-dire que plusieurs threads mettent à jour un certain Lorsqu'une variable est ajoutée, le l'ancienne valeur sera comparée à l'adresse mémoire. Si elles sont égales, elle sera mise à jour avec la nouvelle valeur.
Nous pouvons utiliser watch pour surveiller une ou plusieurs clés. Si après le démarrage d'une transaction, au moins une des clés surveillées est modifiée avant l'exécution de exec, la transaction entière sera annulée.

Tout d'abord, le client 1 exécute une surveillance pour surveiller l'argent de base et démarre une transaction pour augmenter l'argent de 100

127.0.0.1:6379> set money 1000
OK
127.0.0.1:6379> watch money
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379> incrby money 100
QUEUED

Avant la fin de la transaction, le client 2 diminue l'argent de 100

127.0.0.1:6379> decrby money 100
(integer) 900

À ce moment, le client 1 met fin à la transaction et la valeur de l'argent n'a pas augmenté, mais diminué, indiquant que la modification de la transaction a échoué

127.0.0.1:6379> exec
(nil)
127.0.0.1:6379> get money
"900"

Script Lua

Le script Lua est un langage de script léger, écrit en langage C, qui ressemble quelque peu aux procédures stockées. Pourquoi utiliser le script Lua ?

Envoyez plusieurs commandes à la fois pour réduire la surcharge du réseau. Redis exécutera le script dans son ensemble pour garantir l'atomicité (les transactions peuvent être remplacées de cette manière) et la réutilisation du script, ce qui permettra à plusieurs clients de terminer plus facilement le script. même logique.

3.1 En utilisant

nous pouvons utiliser la commande suivante pour appeler le script lua

eval script numkeys [key1 key2 key3 ....] [arg1 arg2 arg3 ....]

eval pour exécuter le script lua

le script représente le contenu du script lua

Nombre de touches numériques

[key1 key2 key3 ....] 键名参数，表示在脚本中所用到的那些 Redis 键(key)，这些键名参数可以在 Lua 中通过全局变量 KEYS 数组，用 1 为基址的形式访问( KEYS[1] ， KEYS[2] ，以此类推)。

[arg1 arg2 arg3 ....] 全局变量，可以在 Lua 中通过全局变量 ARGV 数组访问，访问的形式和 KEYS 变量类似( ARGV[1] 、 ARGV[2] ，诸如此类)

来个简单的例子

127.0.0.1:6379> eval "return {KEYS[1],ARGV[1],KEYS[2],ARGV[2]}" 2 key1 key2 val1 val1
1) "key1"
2) "val1"
3) "key2"
4) "val1"
127.0.0.1:6379> eval "return {KEYS[1],KEYS[2],ARGV[1],ARGV[2]}" 2 key1 key2 val1 val1
1) "key1"
2) "key2"
3) "val1"
4) "val1"

在lua脚本如何调用redis命令呢？
我们可以使用 redis.call(command, key [param1, param2…])进行操作

commond redis的命令，如set，get等key 被操作的键[param1, param2…]表示给key的参数

127.0.0.1:6379> eval "redis.call('mset',KEYS[1],ARGV[1],KEYS[2],ARGV[2])" 2 name age lisi 18
(nil)
127.0.0.1:6379> mget name age
1) "lisi"
2) "18

以上命令等价于 mset name lisi age 18, key的数量为2,2 后面两个值为key，在之后就是args

直接在redis-cli中写lua脚本不够方便，通常我们会把脚本放在文件中，然后执行这个文件
我们在一个目录下新建一个test.lua的脚本，填写以下内容后执行。

root@VM-0-5-centos src]# mkdir testlua
[root@VM-0-5-centos src]# cd testlua/
[root@VM-0-5-centos testlua]# ll
total 0
[root@VM-0-5-centos testlua]# touch test.lua
[root@VM-0-5-centos testlua]# vim test.lua
redis.call('set',KEYS[1],ARGV[1])
return redis.call('get',KEYS[1])
[root@VM-0-5-centos testlua]# redis-cli --eval test.lua 1 myname , Armin
"Armin"

值得注意的是key和arg之间需要加上空格逗号空格（myname , Armin）

3.2 缓存lua脚本

之所以需要缓存lua脚本，这是因为每次调用的时候都将整个脚本传给redis服务端，会产生较大的网络开销。为了解决这个问题，Redis提供了evalsha命令，让开发人员通过脚本内容的SHA1摘要执行脚本。

那么怎么将生成这个SHA1并将脚本内容加载到缓存呢，这就用到script load命令去计算脚本的SHA1摘要并记录脚本到缓存中，执行evalsha时，redis会根据提供的摘要去脚本缓存找到对应脚本内容，如果找到则执行，否则返回错误提示: “NOSCRIPT No matching script. Please use EVAL”

127.0.0.1:6379> script load "return 'Hey boy'"
"3760855b303510c83f0be2e8acfb0be64113ae6e"
127.0.0.1:6379> evalsha 3760855b303510c83f0be2e8acfb0be64113ae6e 0
"Hey boy"
127.0.0.1:6379> script exists 3760855b303510c83f0be2e8acfb0be64113ae6e //判断是否存在
1) (integer)

Redis还给lua脚本的执行提供了超时时间，默认的超时时间为5s，超过5s之后redis会接受其他命令但是会返回一个"BUSY"的错误
可在redis.conf中修改指定参数

lua-time-limit 5000

Redis提供了个script kill的命令来终止正在运行的脚本

127.0.0.1:6379> set name lisi
(error) BUSY Redis is busy running a script. You can only call SCRIPT KILL or SHUTDOWN NOSAVE.
127.0.0.1:6379> script kill
OK
127.0.0.1:6379> set name lisi
OK

如果数据进行了修改操作，将无法使用script kill终止脚本，因为违反了原子性。此时只能通过shutdown nosave来强行终止redis。
shutdown nosave 和 shutdown 的区别在于 shutdown nosave 不会进行持久化 操作，意味着发生在上一次快照后的数据库修改都会丢失。

相关推荐：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!