Comment implémenter le verrouillage distribué Java

1. Introduction aux verrous distribués

Multi-threading sur une seule machine : en Java, nous utilisons généralement des verrous locaux tels que la classe ReetrantLock et le mot-clé synchronisé pour contrôler l'accès de plusieurs threads dans un processus JVM aux ressources partagées locales

Système distribué : différents services/clients s'exécutent généralement sur des processus JVM indépendants. Si plusieurs processus JVM partagent la même ressource, il n'existe aucun moyen d'obtenir un accès mutuellement exclusif à la ressource à l'aide de verrous locaux. Ainsi, les verrous distribués sont nés.

Par exemple : Au total, 3 copies du service de commande du système sont déployées, qui fournissent toutes des services au monde extérieur. Les utilisateurs doivent vérifier l'inventaire avant de passer une commande. Afin d'éviter la survente, un verrou est nécessaire pour obtenir un accès synchrone à l'opération de vérification de l'inventaire. Étant donné que le service de commande se trouve dans un processus JVM différent, les verrous locaux ne fonctionneront pas correctement dans ce cas. Nous devons utiliser des verrous distribués, de sorte que même si plusieurs threads ne sont pas dans le même processus JVM, ils puissent obtenir le même verrou, obtenant ainsi un accès mutuellement exclusif aux ressources partagées.

Un verrou distribué le plus basique doit répondre à :

• Exclusion mutuelle : à tout moment, le verrou ne peut être détenu que par un seul thread

• Haute disponibilité : le service de verrouillage est hautement disponible ; De plus, même s'il y a un problème avec la logique du code du client pour libérer le verrou, le verrou finira par être libéré et n'affectera pas l'accès des autres threads aux ressources partagées.

• Réentrant : une fois qu'un nœud a acquis le verrou, il peut l'acquérir à nouveau.

2. Implémentation de verrous distribués basés sur Redis

1 Comment implémenter le verrou distribué le plus simple basé sur Redis

Qu'il s'agisse d'un verrou local ou d'un verrou distribué, le cœur réside dans "l'exclusion mutuelle" ==.

Dans Redis, SETNX 命令是可以帮助我们实现互斥。SETNXC'est-à-dire SET if Not eXists (correspondant à la méthode setIfAbsent en Java). Si la clé n'existe pas, la valeur de la clé sera définie. Si la clé existe déjà, SETNX ne fait rien.

> SETNX lockKey uniqueValue
(integer) 1
> SETNX lockKey uniqueValue
(integer) 0

Pour déverrouiller, supprimez la clé correspondante directement via la commande DEL

> entier) 1

Afin d'éviter de supprimer accidentellement d'autres verrous, nous vous recommandons ici d'utiliser le script Lua pour juger par la valeur (valeur unique) correspondant à la clé.

Le script Lua est choisi pour assurer l'atomicité de l'opération de déverrouillage. Parce que Redis peut exécuter des scripts Lua de manière atomique, garantissant ainsi l'atomicité de l'opération de déverrouillage.

// 释放锁时，先比较锁对应的 value 值是否相等，避免锁的误释放
if redis.call("get",KEYS[1]) == ARGV[1] then
    return redis.call("del",KEYS[1])
else
    return 0
end

Il s'agit de l'implémentation de verrouillage distribué Redis la plus simple. La méthode d'implémentation est relativement simple et les performances sont très efficaces. Cependant, la mise en œuvre du verrouillage distribué de cette manière pose certains problèmes. Par exemple, si l'application rencontre des problèmes, tels que la logique de libération du verrou qui raccroche soudainement, le verrou peut ne pas être libéré et les ressources partagées ne sont plus accessibles par d'autres threads/processus.

2. Pourquoi définir un délai d'expiration pour le verrou

Principalement pour empêcher le déverrouillage du verrou

127.0.0.1:6379> SET lockKey uniqueValue EX 3 NX

OK

• lockKey : le nom du verrou verrouillé ;

• uniqueValue : une chaîne aléatoire qui peut identifier de manière unique le verrou ;

• NX : SET ne peut réussir que lorsque la valeur de clé correspondant à la lockKey n'existe pas

• EX : paramètre de délai d'expiration ( en secondes) ) EX 3 indique que ce verrou a un délai d'expiration automatique de 3 secondes. Correspondant à EX est PX (en millisecondes), qui sont tous deux des paramètres de délai d'expiration.

Assurez-vous que la définition de la valeur et du délai d'expiration de la clé spécifiée est une opération atomique ! ! ! Sinon, il se peut que le problème ne puisse pas être libéré.

Cette solution présente également des failles :

• Si le temps d'exploitation de la ressource partagée est supérieur au délai d'expiration, le verrou expirera prématurément, ce qui entraînera la défaillance directe du verrou distribué

• Si le le délai d'expiration du verrouillage est défini S'il est trop long, cela affectera les performances

3. Comment réaliser un renouvellement gracieux des verrous

Redisson est un client Redis en langage Java open source qui fournit de nombreuses fonctions prêtes à l'emploi, y compris non seulement plusieurs distributions Implémentation du verrouillage. De plus, Redisson prend également en charge plusieurs architectures de déploiement telles que Redis autonome, Redis Sentinel et Redis Cluster.

Le verrou distribué de Redisson est livré avec un mécanisme de renouvellement automatique. Il est très simple à utiliser et le principe est relativement simple. Il fournit un Watch Dog spécialement utilisé pour surveiller et renouveler le verrou si vous exploitez des ressources partagées. Si l'exécution n'est pas terminée, Watch Dog prolongera continuellement le délai d'expiration du verrou pour garantir que le verrou ne sera pas libéré en raison d'un délai d'attente.

使用方式举例：

// 1.获取指定的分布式锁对象
RLock lock = redisson.getLock("lock");
// 2.拿锁且不设置锁超时时间，具备 Watch Dog 自动续期机制
lock.lock();
// 3.执行业务
...
// 4.释放锁
lock.unlock();

只有未指定锁超时时间，才会使用到 Watch Dog 自动续期机制。

// 手动给锁设置过期时间，不具备 Watch Dog 自动续期机制
lock.lock(10, TimeUnit.SECONDS);

总的来说就是使用Redisson，它带有自动的续期机制

4. 如何实现可重入锁

所谓可重入锁指的是在一个线程中可以多次获取同一把锁，比如一个线程在执行一个带锁的方法，该方法中又调用了另一个需要相同锁的方法，则该线程可以直接执行调用的方法即可重入 ，而无需重新获得锁。像 Java 中的 synchronized 和 ReentrantLock 都属于可重入锁。

可重入分布式锁的实现核心思路是线程在获取锁的时候判断是否为自己的锁，如果是的话，就不用再重新获取了。为此，我们可以为每个锁关联一个可重入计数器和一个占有它的线程。当可重入计数器大于 0 时，则锁被占有，需要判断占有该锁的线程和请求获取锁的线程是否为同一个。

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!