Un article expliquant en détail comment utiliser Redis pour implémenter des verrous distribués

Cet article vous apporte des connaissances pertinentes sur Redis. Il présente principalement un article qui explique en détail comment utiliser Redis pour implémenter des verrous distribués. Examinons-le ensemble, j'espère. vous être utile.

Apprentissage recommandé : Tutoriel vidéo Redis

1. Qu'est-ce que le verrouillage distribué

Lorsque nous écrivons du code multithread, différents threads peuvent rivaliser pour les ressources Afin d'éviter la concurrence des ressources, les erreurs, nous le ferons. verrouille la ressource, et seul le thread qui a obtenu le verrou peut continuer à s'exécuter.

Le verrou dans le processus est essentiellement une variable dans la mémoire. Lorsqu'un thread effectue une opération pour demander un verrou, s'il parvient à définir la valeur de la variable représentant le verrou sur 1, cela signifie que le verrou a été obtenu et d'autres threads veulent l'obtenir. Il se bloquera lors du verrouillage, et une fois que le thread possédant le verrou aura terminé l'opération, il définira la valeur du verrou sur 0, ce qui signifie que le verrou est libéré.

Ce dont nous parlons ci-dessus, c'est le verrou entre différents threads dans le processus d'un serveur. Ce verrou est placé en mémoire, et pour les applications distribuées, différentes applications (processus ou threads) sont déployées sur différents serveurs afin que. les verrous ne peuvent pas être représentés par des variables en mémoire.

Maintenant que le verrou peut être représenté par l'espace mémoire partagé sur un serveur, pour les applications distribuées, le système de stockage peut être partagé pour stocker un verrou partagé, et Redis. En tant que base de données en mémoire, elle s'exécute très rapidement et convient parfaitement comme système de stockage partagé pour la mise en œuvre de verrous distribués. 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. Utilisez Redis pour implémenter des verrous distribués🎜. 🎜Pour un verrou, il n'y a en fait que deux opérations, verrouiller et libérer le verrou. Voyons comment l'implémenter via Redis ? 🎜

2.1 Verrouillage

🎜La commande setnx de Redis déterminera si la valeur de la clé existe. Si elle existe, rien. sera effectuée et renvoie 0. S'il n'existe pas, créez et attribuez une valeur, et renvoyez 1, afin que nous puissions exécuter setnx pour définir une valeur pour une clé de verrouillage représentative si le. Le réglage est réussi, cela signifie que le verrou est obtenu. Échec Le verrou ne peut pas être obtenu. 🎜

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

2.2 Libérer le verrou

🎜Après avoir effectué l'opération, lorsque vous souhaitez déverrouiller le verrou, modifiez directement la valeur de la clé lockRedis /code>Supprimez-le simplement, afin que d'autres processus puissent se réinitialiser et obtenir le verrou via la commande <code>setnx. 🎜

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

🎜Grâce aux deux commandes ci-dessus, nous avons implémenté un simple verrouillage distribué, mais il y a un problème ici : si un processus est verrouillé via la commande setnx, une erreur se produit lors de l'opération spécifique, il n'y a aucun moyen de libérer le verrou à temps, alors les autres processus ne pourront pas obtenir le verrou et le système ne pourra pas continuer l'exécution. La façon de résoudre ce problème est de définir une période de validité pour le verrou, et après cette période de validité, le verrou sera automatiquement libéré. 🎜

2.3 Définir la période de validité du verrou

🎜Il est très simple de définir la période de validité du verrou. Utilisez simplement la commande expire de. Redis , tel que : 🎜

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

🎜 Cependant, un autre problème survient maintenant si nous définissons le verrou et que le processus se bloque avant d'exécuter la commande expire, alors expire<.>L'exécution n'a pas réussi et le verrou n'est pas libéré, nous devons donc nous assurer que les deux commandes ci-dessus sont exécutées ensemble. Comment s'en assurer ? 🎜🎜Il existe deux méthodes, l'une consiste à utiliser un script écrit dans le langage <code>LUA et l'autre consiste à utiliser la commande set de Redis, set Une fois que la commande est suivie du paramètre nx, l'effet d'exécution est cohérent avec setnx et set code> peut être suivie du paramètre <code>ex code> pour définir le délai d'expiration, nous pouvons donc utiliser la commande set pour fusionner le setnx et expire ensemble, afin que l'exécution puisse être garantie par l'atomicité. 🎜rrreee🎜 a résolu le problème des serrures efficaces, regardons maintenant un autre problème. 🎜🎜🎜🎜Comme le montre l'image ci-dessus, il y a désormais, les A, B et C doivent tous obtenir des verrous lors de l'exécution d'une certaine opération et libérer les verrous après l'exécution . 🎜

现在的情况是进程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视频教程

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!