Utilisez Redis pour implémenter des verrous distribués afin de garantir la sécurité des données

Avec le développement continu de la technologie Internet, les systèmes distribués deviennent de plus en plus courants dans le développement, en particulier dans les scénarios de traitement à haute concurrence et de traitement de données à grande échelle. Les systèmes distribués peuvent améliorer l'évolutivité du système et améliorer l'efficacité. du système. Performances et concurrence. Cependant, dans un système distribué, les données étant dispersées sur plusieurs machines, il est facile de rencontrer des problèmes tels qu'une incohérence des données ou des opérations répétées. Afin de résoudre ces problèmes, nous devons souvent utiliser des verrous distribués.

Le verrouillage distribué est un mécanisme de verrouillage proposé pour maintenir la cohérence des données dans les systèmes distribués. Il est principalement utilisé pour éviter des problèmes tels que la concurrence des données et l'incohérence des données dans les systèmes distribués. Dans le mécanisme de verrouillage autonome traditionnel, il est généralement implémenté à l'aide de Synchronized ou ReentrantLock. Cependant, dans un système distribué, la solution de mise en œuvre du verrouillage doit prendre en compte des problèmes tels que le délai de réseau et la concurrence, ce qui nécessite l'utilisation d'une technologie de verrouillage distribuée spéciale.

Redis, en tant que base de données de stockage clé-valeur hautes performances, est souvent utilisée pour implémenter le mécanisme de verrouillage des systèmes distribués. Redis fournit une variété de méthodes d'implémentation de verrous distribués, telles que des verrous basés sur des commandes SETNX, des verrous basés sur l'algorithme Redlock et des verrous basés sur des scripts Lua. Ensuite, nous vous présenterons la solution d'implémentation de verrouillage distribué de Redis basée sur la commande SETNX.

Principe de mise en œuvre du verrouillage distribué Redis

La commande SETNX de Redis est utilisée pour définir la valeur d'une certaine clé dans Redis. Si la clé n'existe pas, le paramètre est réussi et 1 est renvoyé. Sinon, le paramètre échoue et 0. est retourné. Nous pouvons utiliser cette fonctionnalité pour implémenter des verrous distribués.

Lorsque nous devons verrouiller certaines données, nous utilisons la commande SETNX pour essayer de définir la valeur d'une certaine clé sur 1. Si le paramètre réussit, cela signifie qu'aucun autre client ne détient actuellement le verrou et que le verrouillage réussit ; si le paramètre échoue, cela signifie que d'autres clients détiennent actuellement le verrou et que le verrouillage échoue. Lors du déverrouillage, il suffit de supprimer la clé correspondant à la serrure.

Étapes de mise en œuvre du verrouillage distribué Redis

Ci-dessous, nous présenterons comment implémenter des verrous distribués via Redis pour garantir la sécurité des données. Les étapes suivantes ne sont que des exemples et doivent être ajustées en fonction des conditions spécifiques des applications réelles.

1. Présentez le client Redis

En Java, nous pouvons utiliser Jedis ou Lettuce, les deux boîtes à outils du client Redis, pour effectuer des opérations liées à Redis. Vous pouvez ajouter les dépendances suivantes dans le fichier pom.xml :

<dependency>
  <groupId>redis.clients</groupId>
  <artifactId>jedis</artifactId>
  <version>3.0.1</version>
</dependency>

2. Créer une connexion Redis

Avant d'utiliser Redis, vous devez créer une connexion avec le service Redis. Vous pouvez utiliser l'objet JedisPool fourni par Jedis. Le paramètre maxTotal spécifie le nombre maximum de connexions dans le pool de connexions, le paramètre maxIdle spécifie le nombre maximum de connexions inactives dans le pool de connexions et le délai d'expiration est défini sur 5 000 millisecondes.

JedisPool jedisPool = new JedisPool(new GenericObjectPoolConfig(),
        "localhost",
        6379, 
        5000, 
        "password");

3. Opération de verrouillage

Nous implémentons la logique de verrouillage et de déverrouillage en encapsulant une classe LockUtil. Dans l'opération de verrouillage, nous essayons d'utiliser la commande SetNx pour définir la valeur d'une certaine clé sur 1. Si le réglage réussit, true est renvoyé si le réglage échoue, cela signifie que le verrou a été occupé par d'autres threads ; et false est renvoyé. Il convient de noter qu'après un verrouillage réussi, un délai d'attente doit être défini pour éviter un blocage pour certaines raisons.

public class LockUtil {

    private static final String LOCK_KEY_PREFIX = "lock:";

    public static boolean lock(String key, int timeout) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            String lockKey = LOCK_KEY_PREFIX + key;
            long start = System.currentTimeMillis();
            while (true) {
                // 使用SETNX命令来设置key的值为1
                long result = jedis.setnx(lockKey, "1");
                // 设置成功
                if (result == 1) {
                    jedis.expire(lockKey, timeout);
                    return true;
                }
                // 设置失败
                else {
                    // 检查是否超时
                    long end = System.currentTimeMillis();
                    if (end - start > timeout) {
                        return false;
                    }
                }
                Thread.sleep(1000);
            }
        } catch (Exception e) {
            return false;
        } finally {
            if (jedis != null) {
                jedis.close();
            }
        }
    }
}

4. Opération de déverrouillage

Dans l'opération de déverrouillage, nous utilisons la commande del pour supprimer la clé et libérer les ressources.

public class LockUtil {
    
    public static boolean unlock(String key) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            String lockKey = LOCK_KEY_PREFIX + key;
            jedis.del(lockKey);
            return true;
        } catch (Exception e) {
            return false;
        } finally {
            if (jedis != null) {
                jedis.close();
            }
        }
    }
}

5. Test

Enfin, vérifiez que notre verrou distribué fonctionne correctement avec un simple test, comme indiqué ci-dessous :

@Test
public void testLock() throws InterruptedException {
    ExecutorService executorService = Executors.newFixedThreadPool(10);
    for (int i = 0; i < 10; i++) {
        executorService.submit(new Runnable() {
            @Override
            public void run() {
                boolean lockResult = LockUtil.lock("test", 5000);
                if (lockResult) {
                    System.out.println(Thread.currentThread().getName() + " get lock");
                    try {
                        // 处理业务
                        Thread.sleep(5000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        LockUtil.unlock("test");
                    }
                } else {
                    System.out.println(Thread.currentThread().getName() + " fail to get lock");
                }
            }
        });
    }
    sleep(100000);
}

Le code ci-dessus créera 10 threads, chaque thread tentera d'acquérir le même verrou sur la clé, effectuez certaines opérations commerciales et libérez la ressource de verrouillage après 5 secondes. Si le verrou distribué est implémenté avec succès, chaque thread peut acquérir le verrou et terminer le traitement métier.

À travers l'exemple ci-dessus, nous pouvons voir qu'en utilisant la commande SETNX de Redis, un mécanisme de verrouillage distribué simple et efficace peut être implémenté pour assurer efficacement la sécurité des données dans le système distribué. Dans le processus de candidature réel, nous devons ajuster et optimiser le plan de mise en œuvre du verrouillage en fonction des scénarios et des besoins commerciaux réels.

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!