Einführung in die erweiterten Funktionen von Redis

Redis (Remote Dictionary Server), der Remote-Wörterbuchdienst, ist eine Open-Source-Schlüsselwertdatenbank vom Protokolltyp, die in der Sprache ANSI C geschrieben ist, das Netzwerk unterstützt, speicherbasiert und persistent sein kann und eine API für mehrere Sprachen bereitstellt .

(Lernvideo-Sharing: Redis-Video-Tutorial)

1. Redis-Veröffentlichungs- und Abonnementmodus

Zusätzlich zur Bereitstellung einer Nachrichtenwarteschlangenmodus-ähnlichen Liste bietet Redis auch eine Reihe von Befehlen zum Implementieren des Veröffentlichungs-/Abonnementmodus. Dadurch können beispielsweise Weibo, öffentliche Konten usw. realisiert werden.

1.2 Abonnieren Sie den Kanal

Der Herausgeber muss die Nachricht an einen Ort senden, an dem Abonnenten die Nachricht abonnieren können. Dieser Ort ist der Kanal. Abonnenten können einen oder mehrere Kanäle abonnieren und alle Abonnenten dieses Kanals erhalten diese Nachricht.

Zwei Clients zum Testen öffnen

客户端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 Abonnieren gemäß den Regeln

Unterstützt? und * Platzhalter. ? steht für ein Zeichen, * steht für 0 oder mehr Zeichen.

Starten Sie vier Redis-CLI, eines als Herausgeber von Nachrichten und die anderen drei als Abonnenten.
Abonnent 1: Sportbezogene Nachrichten abonnieren

psubscribe *sport

Abonnent 2: Nachrichten zum Thema abonnieren

psubscribe news*

Abonnent 3: Wetterbezogene Nachrichten abonnieren

psubscribe new weather*

Herausgeber:

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

Zu diesem Zeitpunkt erhält Abonnent 1 Kobe, Abonnent Abonnent 2 alle Informationen und Teilnehmer 3 erhält den Regen.

2.redis-Transaktion

2.1 Warum Transaktionen verwenden? Wir alle wissen, dass ein einzelner Befehl von Redis atomar ist, aber wenn Sie mehrere Befehle als unteilbare Folge von Operationen verwenden müssen, müssen Sie Affären verwenden.

Wenn wir beispielsweise setnx zum Implementieren einer verteilten Sperre verwenden, legen wir diese normalerweise zuerst fest und setzen dann „expire“ für den Schlüssel, um zu verhindern, dass die Sperre freigegeben wird, wenn eine Ausnahme in del auftritt Ich hoffe, diese drei Operationen als Befehlssatz ausführen zu können.

Redis-Transaktionen haben zwei Eigenschaften:

werden in der Reihenfolge ausgeführt, in der sie in die Warteschlange gelangen
werden von anderen Client-Anfragen nicht beeinflusst
Redis-Transaktionsdesign hat vier Befehle: multi (Transaktion starten), exec (Transaktion ausführen), dicard (Transaktion abbrechen), beobachten (überwachen)

2.2 Verwendung der Transaktion

Übertragungsszenario A und B haben jeweils 100 Yuan, A überweist 10 Yuan an B, A zieht 10 Yuan ab und B fügt 10 Yuan hinzu

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"

Starten Sie Transaktionen über den Multi-Befehl. Transaktionen können nicht verschachtelt werden. Nach der Verwendung von Multi zum Starten einer Transaktion werden diese Befehle nicht sofort ausgeführt, sondern in eine Warteschlange gestellt Nach dem Aufruf werden die Befehle in der Warteschlange ausgeführt.

Wir können Discard verwenden, um die Transaktionswarteschlange zu leeren.

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)

Wenn bei der Ausführung der Transaktion ein Problem auftritt, wird es dann zurückgesetzt?

Ein Fehler tritt vor exec auf (z. B. ein Befehlssyntaxfehler).

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)

Ein Fehler tritt nach exec auf (bei Verwendung von Befehlen unterschiedlicher Datentypen für denselben Schlüssel).

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"

Durch die oben genannten Vorgänge können wir erkennen, dass ein Transaktionsfehler vorliegt Tritt vor exec auf, werden alle Vorgänge zurückgesetzt; wenn nach exec ein Fehler auftritt, wird nur der fehlerhafte Befehl nicht ausgeführt.

Warum führt Redis kein Rollback durch, wenn bei einer Transaktion ein Fehler auftritt?

Aus der obigen Operation können wir ersehen, dass Redis nur dann ein Rollback durchführt, wenn die Befehlssyntax falsch ist und Befehlsoperationsfehler von Entwicklern verursacht werden. Beispiel: Sie +1 für einen int-Typ und dann versehentlich +2 oder +1 Ein String-Typ, Rollback ist nicht anwendbar

2.3 Überwachungsbefehl

Es kann CAS-optimistische Sperroperationen für Redis-Transaktionen bereitstellen, d gleich sind, werden sie auf den neuen Wert aktualisiert.

Wir können watch verwenden, um einen oder mehrere Schlüssel zu überwachen. Wenn nach dem Start einer Transaktion mindestens einer der überwachten Schlüssel geändert wird, bevor exec ausgeführt wird, wird die gesamte Transaktion abgebrochen.

Zuerst führt Kunde 1 eine Überwachung aus, um das Schlüsselgeld zu überwachen, und startet eine Transaktion, um das Geld um 100 zu erhöhen.

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

Bevor die Transaktion endet, verringert Kunde 2 das Geld um 100. und der Wert des Geldes ist nicht erhöht, sondern verringert, was darauf hinweist, dass die Änderung der Transaktion ungültig ist ähnlich einer gespeicherten Prozedur. Warum Lua-Skript verwenden?

Senden Sie mehrere Befehle gleichzeitig, um den Netzwerkaufwand zu reduzieren. Redis führt das Skript als Ganzes aus, um die Atomizität (Transaktionen können auf diese Weise ersetzt werden) und die Wiederverwendung von Skripten sicherzustellen, wodurch es für mehrere Clients einfacher wird, dieselbe Logik auszuführen.

3.1 Mit

können wir den folgenden Befehl verwenden, um das Lua-Skript aufzurufen

127.0.0.1:6379> decrby money 100
(integer) 900

eval, um das Lua-Skript auszuführen. Das Skript repräsentiert den Inhalt des Lua-Skripts

[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数据库教程

Das obige ist der detaillierte Inhalt vonEinführung in die erweiterten Funktionen von Redis. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!