Ein Artikel, der ausführlich erklärt, wie man Redis zum Implementieren verteilter Sperren verwendet

Dieser Artikel vermittelt Ihnen relevantes Wissen über Redis. Er stellt hauptsächlich die Verwendung von Redis zur Implementierung verteilter Sperren vor. Ich hoffe, dass dies der Fall ist Dir nützlich sein.

Empfohlenes Lernen: Redis-Video-Tutorial

1. Was ist eine verteilte Sperre? Wenn wir Multithread-Code schreiben, konkurrieren möglicherweise verschiedene Threads um Ressourcen Sperren Sie die Ressource, und nur der Thread, der die Sperre erhalten hat, kann mit der Ausführung fortfahren.

Die Sperre im Prozess ist im Wesentlichen eine Variable im Speicher. Wenn ein Thread eine Operation zur Beantragung einer Sperre ausführt und der Wert der Variablen, die die Sperre darstellt, erfolgreich auf 1 gesetzt werden kann, bedeutet dies, dass die Sperre erfolgt ist erhalten, und andere Threads möchten es erhalten, wenn es gesperrt wird, und nachdem der Thread, der die Sperre besitzt, den Vorgang abschließt, setzt er den Wert der Sperre auf 0, was bedeutet, dass die Sperre aufgehoben wird.

Wovon wir oben sprechen, ist die Sperre zwischen verschiedenen Threads im Prozess eines Servers. Diese Sperre wird im Speicher platziert, und bei verteilten Anwendungen werden verschiedene Anwendungen (Prozesse oder Threads) auf verschiedenen Servern bereitgestellt Sperren können nicht durch Variablen im Speicher dargestellt werden.

Da die Sperre nun durch den gemeinsam genutzten Speicherbereich auf einem Server dargestellt werden kann, kann für verteilte Anwendungen das Speichersystem gemeinsam genutzt werden, um eine gemeinsam genutzte Sperre und Redis zu speichern Als In-Memory-Datenbank wird sie sehr schnell ausgeführt und eignet sich sehr gut als gemeinsames Speichersystem zur Implementierung verteilter Sperren.

Redis作为内存数据库，执行非常快，很适合作为实现分布式锁的共享存储系统。

2. 使用Redis实现分布式锁

对于一个锁来说，其实只有两个操作，加锁和释放锁，下面我们看来看通过Redis要怎么实现？

2.1 加锁

Redis的setnx命令会判断键值是否存在，如果存在则不做任何操作，并返回0，如果不存在，则创建并赋值，并返回1，因此我们可以执行setnx为一个代表锁键设置值，如果能设置成功，则表示获得锁，失败则无法获得锁。

# 使用key为lock来表示一个锁
setnx lock 1

2.2 释放锁

当执行好操作之后，要释放锁的时候直接把Redis里的键值lock删除就可以了，这样其他进程才能通过setnx命令重新设置并获得该锁。

# 释放锁
del lock

通过上面两个命令，我们实现了一个简单的分布式锁，但这里就出现了一个问题：如果一个进程通过setnx命令加锁之后，在执行具体操作出错了，没有办法及时释放锁，那么其他进程就无法获得该锁，系统便无法继续往下执行，解决这个问题的办法就是为锁设置一个有效期，在这个有效期之后，自动释放锁。

2.3 给锁设置有效期

给锁设置有效期非常简单，直接使用Redis的expire命令就可以了，如：

# 加锁
setnx lock 1 
# 给锁设置10s有效期
expire lock 10

但是，现在又出现另一个问题了，如果我们在设置了锁之后，执行expire命令之前该进程挂掉了，那么expire就没有执行成功，锁一样是没有被释放掉的，所以一定要保证上面两个命令要一起执行，怎么保证呢？

有两个方法，一个是使用LUA语言编写的脚本，另一个是使用Redis的set命令，set命令后面跟nx参数后，执行的效果与setnx一致，且set命令可以跟ex参数来设置过期时间，所以我们可以使用set命令把setnx和expire两个合并在一起，这样就可以保证执行的原子性了。

# 判断是否键值是否存在，ex后面跟着的是键值的有效期,10s
set lock 1 nx ex 10

解决了锁的有效问题，现在我们再来看另外一个问题。

如上图所示，现在有A，B，C

2. Verwenden Sie Redis, um verteilte Sperren zu implementieren🎜 🎜Für eine Sperre gibt es eigentlich nur zwei Vorgänge: Sperren und Freigeben der Sperre. Mal sehen, wie man sie über Redis implementiert. 🎜

2.1 Sperren

🎜Rediss Befehl setnx ermittelt, ob der Schlüsselwert vorhanden ist, nichts wird ausgeführt und gibt 0 zurück. Wenn er nicht existiert, erstellen und weisen Sie einen Wert zu und geben Sie 1 zurück, damit wir setnx ausführen können, um einen Wert für einen repräsentativen Sperrschlüssel festzulegen Wenn die Einstellung erfolgreich ist, bedeutet dies, dass die Sperre erhalten wurde. Fehler Die Sperre kann nicht erhalten werden. 🎜

 # rand_uid表示唯一id
set lock rand_id nx ex 10

2.2 Sperre aufheben

🎜Wenn Sie nach dem Ausführen des Vorgangs die Sperre aufheben möchten, ändern Sie direkt den Schlüsselwert lockRedis /code>Löschen Sie es einfach, damit andere Prozesse die Sperre über den Befehl <code>setnx zurücksetzen und erhalten können. 🎜

if redis.call("get",KEYS[1]) == ARGV[1] then 
  return redis.call("del",KEYS[1])
else 
  return 0
end

🎜Durch die beiden oben genannten Befehle haben wir eine einfache verteilte Sperre implementiert, aber hier gibt es ein Problem: Wenn ein Prozess über den Befehl setnx gesperrt wird, tritt während des spezifischen Vorgangs ein Fehler auf. Wenn es keine Möglichkeit gibt, die Sperre rechtzeitig aufzuheben, können andere Prozesse die Sperre nicht erhalten und das System kann die Ausführung nicht fortsetzen. Die Lösung dieses Problems besteht darin, einen Gültigkeitszeitraum für die Sperre festzulegen. und nach Ablauf dieser Gültigkeitsdauer wird die Sperre automatisch aufgehoben. 🎜

2.3 Legen Sie die Gültigkeitsdauer der Sperre fest

🎜Es ist sehr einfach, die Gültigkeitsdauer der Sperre festzulegen. Verwenden Sie einfach den Befehl expire Redis , wie zum Beispiel: 🎜

# lock为key,rand_id表示key里保存的值
redis-cli --eval unlock.lua lock , rand_id

🎜 Allerdings tritt jetzt ein weiteres Problem auf, wenn wir die Sperre setzen und der Prozess hängt, bevor der Befehl expire ausgeführt wird, dann expireDie Ausführung ist nicht erfolgreich und die Sperre wird nicht aufgehoben. Daher müssen wir sicherstellen, dass die beiden oben genannten Befehle zusammen ausgeführt werden. 🎜🎜Es gibt zwei Methoden: Eine besteht darin, ein in der Sprache <code>LUA geschriebenes Skript zu verwenden, und die andere darin, den Befehl set von Rediszu verwenden >, set Nachdem dem Befehl der Parameter nx folgt, stimmt der Ausführungseffekt mit setnx und dem set überein. Auf den Befehl code> kann der Parameter <code>ex code> folgen, um die Ablaufzeit festzulegen. Daher können wir den Befehl set verwenden, um setnx und zusammenzuführen expire zusammen, sodass die Ausführung garantiert atomar sein kann. 🎜rrreee🎜 hat das Problem effektiver Sperren gelöst, jetzt schauen wir uns ein anderes Problem an. 🎜🎜🎜🎜Wie im Bild oben gezeigt, gibt es Jetzt müssen A, B und C alle Sperren erhalten, wenn sie einen bestimmten Vorgang ausführen, und die Sperren nach der Ausführung freigeben . 🎜

现在的情况是进程A执行第2步时卡顿了(上面绿色区域所示)，且时间超出了锁有效期，所以进程A设置的锁自动释放了，这时候进程B获得了锁，并开始执行操作，但由于进程A只是卡顿了而已，所以会继续执行的时候，在第3步的时候会手动释放锁，但是这个时候，锁由线程B所拥有，也就是说进程A删除的不是自己的锁，而进程B的锁，这时候进程B还没执行完，但锁被释放后，进程C可以加锁，也就是说由于进程A卡顿释放错了锁，导致进程B和进程C可以同时获得锁。

怎么避免这种情况呢？如何区分其他进程的锁，避免删除其他进程的锁呢？答案就是每个进程在加锁的时候，给锁设置一个唯一值，并在释放锁的时候，判断是不是自己设置的锁。

2.4 给锁设置唯一值

给锁设置唯一值的时候，一样是使用set命令，唯一的不同是将键值1改为一个随机生成的唯一值，比如uuid。

 # rand_uid表示唯一id
set lock rand_id nx ex 10

当锁里的值由进程设置后，释放锁的时候，就需要判断锁是不是自己的，步骤如下：

• 通过Redis的get命令获得锁的值
• 根据获得的值，判断锁是不是自己设置的
• 如果是，通过del命令释放锁。

此时我们看到，释放锁需要执行三个操作，如果三个操作依次执行的话，是没有办法保证原子性的，比如进程A在执行到第2步后，准备开始执行del命令时，而锁由时有效期到了，被自动释放了，并被其他服务器上的进程B获得锁，但这时候线程A执行del还是把线程B的锁给删掉了。

解决这个问题的办法就是保证上述三个操作执行的原子性，即在执行释放锁的三个操作中，其他进程不可以获得锁，想要做到这一点，需要使用到LUA脚本。

2.5 通过LUA脚本实现释放锁的原子性

Redis支持LUA脚本，LUA脚里的代码执行的时候，其他客户端的请求不会被执行，这样可以保证原子性操作，所以我们可以使用下面脚本进行锁的释放：

if redis.call("get",KEYS[1]) == ARGV[1] then 
  return redis.call("del",KEYS[1])
else 
  return 0
end

将上述脚本保存为脚本后，可以调用Redis客户端命令redis-cli来执行，如下：

# lock为key,rand_id表示key里保存的值
redis-cli --eval unlock.lua lock , rand_id

推荐学习：Redis视频教程

Das obige ist der detaillierte Inhalt vonEin Artikel, der ausführlich erklärt, wie man Redis zum Implementieren verteilter Sperren verwendet. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!