Comment utiliser le verrouillage optimiste et le verrouillage pessimiste Redis

Concept

Redis est un système de stockage clé-valeur en mémoire qui prend en charge une variété de structures de données, notamment des chaînes, des hachages, des listes, etc. Redis propose deux mécanismes de verrouillage, à savoir le verrouillage optimiste et le verrouillage pessimiste.

Verrouillage optimiste

Le verrouillage optimiste est une stratégie de contrôle de concurrence optimiste. Il estime que les données ne seront pas occupées par d'autres threads dans la plupart des cas, les données doivent donc être modifiées à chaque fois. à ce moment-là, le verrou ne sera pas acquis, mais la modification sera effectuée directement. Dans Redis, le verrouillage optimiste peut être implémenté via les commandes WATCH et CAS. La commande WATCH est utilisée pour surveiller une ou plusieurs clés, et la commande CAS est utilisée pour vérifier et mettre à jour la valeur de la clé.

Par exemple, s'il existe un compteur avec le nom de clé compteur, plusieurs clients doivent opérer dessus. Vous pouvez utiliser le verrouillage optimiste pour surveiller la clé du compteur avant chaque opération client en exécutant la commande WATCH

WATCH counter
current_count = GET counter
new_count = current_count + 1
MULTI
SET counter new_count
EXEC

Ensuite, avant l'exécution de la commande EXEC, utilisez la commande GET pour obtenir à nouveau la valeur de la clé du compteur , et comparez-le à la valeur obtenue précédemment. Si les valeurs sont égales, cela signifie qu'aucun autre client n'a modifié la clé du compteur pendant la période, vous pouvez utiliser la commande CAS pour définir la nouvelle valeur sur la clé du compteur. Si les valeurs sont différentes, cela signifie que d'autres clients ont modifié la clé du compteur pendant cette période et que l'opération doit être refaite.

GET counter

verrouillage pessimiste

Le verrouillage pessimiste est une stratégie de contrôle de concurrence pessimiste. Il pense que les données seront occupées par d'autres threads dans la plupart des cas, les données doivent donc être modifiées à chaque fois. time Ce faisant, le verrou sera acquis en premier pour garantir qu'aucun autre thread ne puisse accéder aux données pendant la modification. Dans Redis, le verrouillage pessimiste peut être implémenté via la commande WATCH, qui peut surveiller une ou plusieurs clés. Si la valeur d'une clé surveillée change pendant l'exécution de la transaction, l'intégralité de la transaction sera annulée.

Toujours l'exemple ci-dessus

WATCH counter
current_count = GET counter
new_count = current_count + 1
MULTI
SET counter new_count
EXEC

Si d'autres clients modifient la clé du compteur pendant l'exécution de la transaction, l'intégralité de la transaction sera annulée et devra être réexécutée.

Bien que le verrouillage pessimiste puisse garantir l'avantage de la cohérence des données, son inconvénient est qu'il doit d'abord acquérir le verrou, ce qui peut provoquer un blocage des threads, affectant ainsi les performances de concurrence.

Exemple de verrouillage optimiste

Supposons qu'il existe une plate-forme de commerce électronique sur laquelle les utilisateurs peuvent acheter des produits. Afin de garantir la cohérence de la réduction des stocks de produits, le mécanisme de verrouillage optimiste de Redis peut être utilisé pour y parvenir.

Tout d'abord, nous devons enregistrer les informations d'inventaire de chaque produit dans Redis, en utilisant une structure de données de hachage pour les enregistrer, par exemple :

Ensuite, dans la logique métier, lorsque l'utilisateur achète Pour un produit, vous devez effectuer les étapes suivantes :

• Utilisez la commande WATCH pour surveiller la clé d'inventaire du produit, telle que stock:sku001 #; 🎜🎜#

• Utilisez la commande GET pour obtenir la quantité actuelle de l'inventaire du produit

• Vérifiez si l'inventaire du produit est suffisant ; . Si elle est insuffisante, renvoyez directement un message d'erreur ;

  #🎜🎜 #

Calculez la nouvelle quantité d'inventaire et utilisez la commande MULTI pour ouvrir une transaction ; #

• Utilisez la commande HSET pour enregistrer la nouvelle quantité d'inventaire dans Redis Medium

• Exécutez la transaction si d'autres clients modifient l'inventaire du produit. lors de l'exécution, la transaction sera annulée et devra être réexécutée.

• Ce qui suit est un exemple de code implémenté à l'aide de Spring Boot :

  @Service
  public class OrderService {
      private final RedisTemplate<String, Integer> redisTemplate;
  
      @Autowired
      public OrderService(RedisTemplate<String, Integer> redisTemplate) {
          this.redisTemplate = redisTemplate;
      }
  
      public void placeOrder(String sku, int quantity) {
          String stockKey = "stock:" + sku;
          while (true) {
              // 监视商品库存键，以便在事务开始前检测是否有其他客户端修改了库存
              redisTemplate.watch(stockKey);
              // 获取当前库存数量
              int currentStock = redisTemplate.opsForHash().get(stockKey, sku);
              // 检查库存是否足够
              if (currentStock < quantity) {
                  // 库存不足，放弃事务并抛出异常
                  redisTemplate.unwatch();
                  throw new RuntimeException("Out of stock");
              }
              // 计算新的库存数量
              int newStock = currentStock - quantity;
              // 开始事务
              redisTemplate.multi();
              // 更新库存数量
              redisTemplate.opsForHash().put(stockKey, sku, newStock);
              // 提交事务
              List<Object> results = redisTemplate.exec();
              // 如果事务执行成功，则退出循环
              if (results != null) {
                  break;
              }
              // 如果事务执行失败，则重试
          }
      }
  }

Dans le code ci-dessus, nous utilisons RedisTemplate pour faire fonctionner Redis, où watch La méthode est utilisée pour surveiller la clé d'inventaire du produit, la méthode opsForHash est utilisée pour obtenir et modifier la valeur de l'inventaire du produit, et les méthodes multi et exec sont utilisées pour ouvrir et soumettre des transactions.

Exemple de verrouillage pessimiste

En plus du verrouillage optimiste, Redis prend également en charge le verrouillage pessimiste, qui peut être obtenu en définissant l'indicateur NX (Not Exist) ou XX (Exist). Par exemple, lorsque l'indicateur NX est défini sur true, si le verrou n'existe pas, OK sera renvoyé et un verrou sera créé ; si le verrou existe déjà, null sera renvoyé, indiquant l'échec de l'acquisition du verrou. Au contraire, lorsque l'indicateur XX est défini sur true, si le verrou existe déjà, OK sera renvoyé, indiquant que l'acquisition du verrou a réussi ; si le verrou n'existe pas, null sera renvoyé, indiquant que l'acquisition du verrou a échoué ; .

Ce qui suit est un exemple de code de verrouillage pessimiste implémenté à l'aide de Spring Boot :

@Service
public class OrderService {
    private final RedisTemplate<String, String> redisTemplate;

    @Autowired
    public OrderService(RedisTemplate<String, String> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    public void placeOrder(String sku, int quantity) {
        String lockKey = "lock:" + sku;
        // 尝试获取锁，如果锁已经存在，说明有其他线程正在执行相关操作
        Boolean locked = redisTemplate.opsForValue().setIfAbsent(lockKey, "locked");
        if (!locked) {
            // 获取锁失败，抛出异常
            throw new RuntimeException("Unable to acquire lock");
        }
        // 设置锁的过期时间，防止锁被一直占用
        redisTemplate.expire(lockKey, 10, TimeUnit.SECONDS);
        try {
            // 执行订单创建、扣减库存等操作
        } finally {
            // 释放锁
            redisTemplate.delete(lockKey);
        }
    }
}

Dans le code ci-dessus, nous utilisons la méthode setIfAbsent pour essayer d'acquérir le verrou. existe déjà, expliquez. D'autres threads effectuent des opérations associées. À ce moment, false sera renvoyé, indiquant que l'acquisition du verrou a échoué, sinon, true sera renvoyé, indiquant que l'acquisition du verrou a réussi ; Nous allons d'abord acquérir le verrou, puis définir le délai d'expiration du verrou et effectuer les opérations correspondantes, et enfin libérer le verrou.

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!