Comment développer des fonctions de verrouillage distribuées à l'aide de Redis et Java

Comment utiliser Redis et Java pour développer une fonction de verrouillage distribué

1. Introduction
   Le verrouillage distribué est un mécanisme permettant d'obtenir un accès mutuellement exclusif aux ressources partagées dans un système distribué. Lorsque plusieurs nœuds accèdent à des ressources partagées en même temps, il est nécessaire de s'assurer qu'un seul nœud accède et que les autres nœuds doivent attendre. Redis est une base de données en mémoire couramment utilisée avec des performances et une fiabilité élevées, et est très adaptée à la mise en œuvre de verrous distribués.
2. Commande setnx de Redis
   La commande setnx de Redis peut être utilisée pour définir la valeur d'une clé, mais l'opération de configuration ne sera effectuée que lorsque la clé n'existe pas. Cette fonctionnalité peut être utilisée pour mettre en œuvre des opérations d'acquisition de verrous distribués. Utilisez la commande setnx pour essayer d'abord de définir une clé avec un délai d'expiration. Si le réglage réussit, cela signifie que le verrou a été acquis avec succès. Sinon, cela signifie que le verrou a été acquis par d'autres nœuds.
3. Exemple de code Java
   Ce qui suit est un exemple de code qui utilise le langage Java et Redis pour implémenter des verrous distribués :

import redis.clients.jedis.Jedis;

public class DistributedLock {
    private static final String LOCK_KEY = "distributed_lock";
    private static final int LOCK_TIMEOUT = 3 * 1000; // 锁的超时时间，单位为毫秒
    
    private Jedis jedis;

    public DistributedLock(Jedis jedis) {
        this.jedis = jedis;
    }

    public boolean lock() {
        long start = System.currentTimeMillis();
        try {
            while (true) {
                String result = jedis.set(LOCK_KEY, "locked", "NX", "PX", LOCK_TIMEOUT);
                if ("OK".equals(result)) {
                    return true;
                } else {
                    // 进行重试
                    Thread.sleep(100);
                }
                long end = System.currentTimeMillis();
                if (end - start > LOCK_TIMEOUT) {
                    // 超时退出
                    return false;
                }
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return false;
        }
    }

    public void unlock() {
        jedis.del(LOCK_KEY);
    }
}

4. Exemple de description
   Dans l'exemple de code ci-dessus, la bibliothèque Jedis est utilisée pour faire fonctionner Redis. Tout d'abord, une constante LOCK_KEY est définie comme la clé du verrou distribué. Cette clé doit rester unique parmi tous les nœuds. De plus, une constante LOCK_TIMEOUT est définie pour représenter le délai d'expiration du verrouillage. LOCK_KEY作为分布式锁的键，这个键在所有节点中必须保持唯一。另外，设置了一个LOCK_TIMEOUT常量来表示锁的超时时间。

在lock方法中，首先获取当前时间作为开始时间，然后使用一个无限循环来尝试获取分布式锁。在循环中，使用Redis的set命令进行设置操作，设置键为LOCK_KEY，值为"locked"，并且设置了NX和PX选项，NX表示只有键不存在时才执行设置操作，PX表示设置键的过期时间为LOCK_TIMEOUT毫秒。

如果设置成功，则表示获取锁成功，方法返回true；否则继续进行重试，每次重试时会等待100毫秒。同时，还需要判断获取锁的时间是否超过了LOCK_TIMEOUT的值，如果超过则表示获取锁的等待时间已经过长，放弃获取锁，并返回false。

在unlock方法中，通过调用del

Dans la méthode lock, obtenez d'abord l'heure actuelle comme heure de début, puis utilisez une boucle infinie pour essayer d'acquérir le verrou distribué. Dans la boucle, utilisez la commande set de Redis pour effectuer l'opération de configuration. La clé set est LOCK_KEY, la valeur est "verrouillée" et NX. et l'option PX, NX signifie que l'opération de paramétrage sera effectuée uniquement lorsque la clé n'existe pas, PX signifie que le délai d'expiration de la clé La clé définie est LOCK_TIMEOUT</ code>millisecondes. <li><br>Si le réglage réussit, cela signifie que le verrou est acquis avec succès et que la méthode renvoie <code>true ; sinon, continuez à réessayer et attendra 100 millisecondes pour chaque nouvelle tentative. Dans le même temps, il est également nécessaire de déterminer si le temps d'acquisition du verrou dépasse la valeur de LOCK_TIMEOUT. S'il dépasse, cela signifie que le temps d'attente pour acquérir le verrou a été trop long, abandonnez l'acquisition du verrou et retournez false .

Exemple d'appel
6. Ce qui suit est un exemple d'appel utilisant l'exemple de code :
   

import redis.clients.jedis.Jedis;

public class LockTest {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("localhost");
        DistributedLock lock = new DistributedLock(jedis);
        try {
            if (lock.lock()) {
                // 获取到分布式锁后执行需要保护的代码
                System.out.println("获取到分布式锁");
                // ... 执行需要保护的代码
            } else {
                System.out.println("获取分布式锁失败");
            }
        } finally {
            lock.unlock();
        }
    }
}

Copier après la connexion
Dans l'exemple d'appel, un objet de connexion Jedis est d'abord créé, puis un objet DistributedLock est créé et l'objet de connexion Jedis est transmis en tant que un paramètre. Dans le bloc try-finally, essayez d'abord d'acquérir le verrou distribué. En cas de succès, affichez « verrouillage distribué obtenu », exécutez le code qui doit être protégé, puis libérez le verrou distribué dans le bloc final. 🎜🎜🎜Résumé🎜En utilisant le développement Redis et Java, nous pouvons facilement implémenter la fonction de verrouillage distribué. L'opération d'acquisition de verrou peut être implémentée à l'aide de la commande Redis setnx, et le code Java peut facilement appeler la commande Redis et l'encapsuler dans une classe de verrouillage distribuée. Dans les applications réelles, le délai d'expiration du verrou distribué peut être ajusté selon les besoins pour garantir que le temps d'attente pour acquérir le verrou ne sera pas trop long, améliorant ainsi les performances et la concurrence du système. 🎜🎜

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!