devbox
从前慢现在也慢
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Redis实现分布式锁方法详细_redis加锁

作者：从前慢现在也慢 | 2024-06-10 01:54:10

赞

踩

redis加锁

目录

前言

1. 单机数据一致性

2. 分布式数据一致性

3. Redis实现分布式锁

3.1 方式一

3.2 方式二（改进方式一）

3.3 方式三（改进方式二）

3.4 方式四（改进方式三）

3.5 方式五（改进方式四）

前言

在单体应用中，如果我们对共享数据不进行加锁操作，会出现数据一致性问题，我们的解决办法通常是加锁。

在分布式架构中，我们同样会遇到数据共享操作问题，本文章使用Redis来解决分布式架构中的数据一致性问题。

1. 单机数据一致性

单机数据一致性架构如下图所示：多个可客户访问同一个服务器，连接同一个数据库。

场景描述：客户端模拟购买商品过程，在Redis中设定库存总数剩100个，多个客户端同时并发购买。

  1. @RestController
  2. public class IndexController1 {
  3.  
  4.     @Autowired
  5.     StringRedisTemplate template;
  6.  
  7.     @RequestMapping("/buy1")
  8.     public String index(){
  9.         // Redis中存有goods:001号商品，数量为100
  10.         String result = template.opsForValue().get("goods:001");
  11.         // 获取到剩余商品数
  12.         int total = result == null ? 0 : Integer.parseInt(result);
  13.         if( total > 0 ){
  14.             // 剩余商品数大于0 ，则进行扣减
  15.             int realTotal = total -1;
  16.             // 将商品数回写数据库
  17.             template.opsForValue().set("goods:001",String.valueOf(realTotal));
  18.             System.out.println("购买商品成功，库存还剩："+realTotal +"件， 服务端口为8001");
  19.             return "购买商品成功，库存还剩："+realTotal +"件， 服务端口为8001";
  20.         }else{
  21.             System.out.println("购买商品失败，服务端口为8001");
  22.         }
  23.         return "购买商品失败，服务端口为8001";
  24.     }
  25. }

使用Jmeter模拟高并发场景，测试结果如下： 

测试结果出现多个用户购买同一商品，发生了数据不一致问题！

解决办法：单体应用的情况下，对并发的操作进行加锁操作，保证对数据的操作具有原子性

  • synchronized
  • ReentrantLock
  1. @RestController
  2. public class IndexController2 {
  3.  
  4.     // 使用ReentrantLock锁解决单体应用的并发问题
  5.     Lock lock = new ReentrantLock();
  6.  
  7.     @Autowired
  8.     StringRedisTemplate template;
  9.  
  10.     @RequestMapping("/buy2")
  11.     public String index() {
  12.  
  13.         lock.lock();
  14.         try {
  15.             String result = template.opsForValue().get("goods:001");
  16.             int total = result == null ? 0 : Integer.parseInt(result);
  17.             if (total > 0) {
  18.                 int realTotal = total - 1;
  19.                 template.opsForValue().set("goods:001", String.valueOf(realTotal));
  20.                 System.out.println("购买商品成功，库存还剩：" + realTotal + "件， 服务端口为8001");
  21.                 return "购买商品成功，库存还剩：" + realTotal + "件， 服务端口为8001";
  22.             } else {
  23.                 System.out.println("购买商品失败，服务端口为8001");
  24.             }
  25.         } catch (Exception e) {
  26.             lock.unlock();
  27.         } finally {
  28.             lock.unlock();
  29.         }
  30.         return "购买商品失败，服务端口为8001";
  31.     }
  32. }

100个商品100个人买最后剩余为0

2. 分布式数据一致性

上面解决了单体应用的数据一致性问题，但如果是分布式架构部署呢，架构如下：

提供两个服务，端口分别为8001、8002，连接同一个Redis服务，在服务前面有一台Nginx作为负载均衡

两台服务代码相同，只是端口不同

将8001、8002两个服务启动，每个服务依然用ReentrantLock加锁，用Jmeter做并发测试，发现会出现数据一致性问题！

 

3. Redis实现分布式锁

3.1 方式一

取消单机锁，下面使用redis的set命令来实现分布式加锁

SET KEY VALUE [EX seconds] [PX milliseconds] [NX|XX]

EX seconds − 设置指定的到期时间(以秒为单位)

PX milliseconds − 设置指定的到期时间(以毫秒为单位)

NX − 仅在键不存在时设置键

XX − 只有在键已存在时才设置

  1. @RestController
  2. public class IndexController4 {
  3.  
  4.     // Redis分布式锁的key
  5.     public static final String REDIS_LOCK = "lock";
  6.  
  7.     @Autowired
  8.     StringRedisTemplate template;
  9.  
  10.     @RequestMapping("/buy4")
  11.     public String index(){
  12.  
  13.         // 每个人进来先要进行加锁，key值为"lock"，value随机生成
  14.         String value = UUID.randomUUID().toString().replace("-","");
  15.         try{
  16.             // 加锁
  17.             Boolean flag = template.opsForValue().setIfAbsent(REDIS_LOCK, value);
  18.             // 加锁失败
  19.             if(!flag){
  20.                 return "抢锁失败！";
  21.             }
  22.             System.out.println( value+ " 抢锁成功");
  23.             String result = template.opsForValue().get("goods:001");
  24.             int total = result == null ? 0 : Integer.parseInt(result);
  25.             if (total > 0) {
  26.                 int realTotal = total - 1;
  27.                 template.opsForValue().set("goods:001", String.valueOf(realTotal));
  28.                 // 如果在抢到所之后，删除锁之前，发生了异常，锁就无法被释放，
  29.                 // 释放锁操作不能在此操作，要在finally处理
  30.                 // template.delete(REDIS_LOCK);
  31.                 System.out.println("购买商品成功，库存还剩：" + realTotal + "件， 服务端口为8001");
  32.                 return "购买商品成功，库存还剩：" + realTotal + "件， 服务端口为8001";
  33.             } else {
  34.                 System.out.println("购买商品失败，服务端口为8001");
  35.             }
  36.             return "购买商品失败，服务端口为8001";
  37.         }finally {
  38.             // 释放锁
  39.             template.delete(REDIS_LOCK);
  40.         }
  41.     }
  42. }

上面的代码，可以解决分布式架构中数据一致性问题。但再仔细想想，还是会有问题，下面进行改进。

3.2 方式二（改进方式一）

在上面的代码中，如果程序在运行期间，部署了微服务jar包的机器突然挂了，代码层面根本就没有走到finally代码块，也就是说在宕机前，锁并没有被删除掉，这样的话，就没办法保证解锁

所以，这里需要对这个key加一个过期时间，Redis中设置过期时间有两种方法：

  • template.expire(REDIS_LOCK,10, TimeUnit.SECONDS)
  • template.opsForValue().setIfAbsent(REDIS_LOCK, value,10L,TimeUnit.SECONDS)

第一种方法需要单独的一行代码，且并没有与加锁放在同一步操作，所以不具备原子性，也会出问题

第二种方法在加锁的同时就进行了设置过期时间，所有没有问题，这里采用这种方式

调整下代码，在加锁的同时，设置过期时间：

  1. // 为key加一个过期时间，其余代码不变
  2. Boolean flag = template.opsForValue().setIfAbsent(REDIS_LOCK,value,10L,TimeUnit.SECONDS);

这种方式解决了因服务突然宕机而无法释放锁的问题。但再仔细想想，还是会有问题，下面进行改进。

3.3 方式三（改进方式二）

方式二设置了key的过期时间，解决了key无法删除的问题，但问题又来了

上面设置了key的过期时间为10秒，如果业务逻辑比较复杂，需要调用其他微服务，处理时间需要15秒（模拟场景，别较真），而当10秒钟过去之后，这个key就过期了，其他请求就又可以设置这个key，此时如果耗时15秒的请求处理完了，回来继续执行程序，就会把别人设置的key给删除了，这是个很严重的问题！

所以，谁上的锁，谁才能删除

  1. @RestController
  2. public class IndexController6 {
  3.  
  4.     public static final String REDIS_LOCK = "lock";
  5.  
  6.     @Autowired
  7.     StringRedisTemplate template;
  8.  
  9.     @RequestMapping("/buy6")
  10.     public String index(){
  11.  
  12.         // 每个人进来先要进行加锁，key值为"lock"
  13.         String value = UUID.randomUUID().toString().replace("-","");
  14.         try{
  15.             // 为key加一个过期时间
  16.             Boolean flag = template.opsForValue().setIfAbsent(REDIS_LOCK, value,10L,TimeUnit.SECONDS);
  17.  
  18.             // 加锁失败
  19.             if(!flag){
  20.                 return "抢锁失败！";
  21.             }
  22.             System.out.println( value+ " 抢锁成功");
  23.             String result = template.opsForValue().get("goods:001");
  24.             int total = result == null ? 0 : Integer.parseInt(result);
  25.             if (total > 0) {
  26.                 // 如果在此处需要调用其他微服务，处理时间较长。。。
  27.                 int realTotal = total - 1;
  28.                 template.opsForValue().set("goods:001", String.valueOf(realTotal));
  29.                 System.out.println("购买商品成功，库存还剩：" + realTotal + "件， 服务端口为8001");
  30.                 return "购买商品成功，库存还剩：" + realTotal + "件， 服务端口为8001";
  31.             } else {
  32.                 System.out.println("购买商品失败，服务端口为8001");
  33.             }
  34.             return "购买商品失败，服务端口为8001";
  35.         }finally {
  36.             // 谁加的锁，谁才能删除！！！！
  37.             if(template.opsForValue().get(REDIS_LOCK).equals(value)){
  38.                 template.delete(REDIS_LOCK);
  39.             }
  40.         }
  41.     }
  42. }

这种方式解决了因服务处理时间太长而释放了别人锁的问题。这样就没问题了吗

3.4 方式四（改进方式三）

在上面方式三下，规定了谁上的锁，谁才能删除，但finally快的判断和del删除操作不是原子操作，并发的时候也会出问题，并发嘛，就是要保证数据的一致性，保证数据的一致性，最好要保证对数据的操作具有原子性。

在Redis的set命令介绍中，最后推荐Lua脚本进行锁的删除，地址：SET | Redis

  1. @RestController
  2. public class IndexController7 {
  3.  
  4.     public static final String REDIS_LOCK = "lock";
  5.  
  6.     @Autowired
  7.     StringRedisTemplate template;
  8.  
  9.     @RequestMapping("/buy7")
  10.     public String index(){
  11.  
  12.         // 每个人进来先要进行加锁，key值为"lock"
  13.         String value = UUID.randomUUID().toString().replace("-","");
  14.         try{
  15.             // 为key加一个过期时间
  16.             Boolean flag = template.opsForValue().setIfAbsent(REDIS_LOCK, value,10L,TimeUnit.SECONDS);
  17.             // 加锁失败
  18.             if(!flag){
  19.                 return "抢锁失败！";
  20.             }
  21.             System.out.println( value+ " 抢锁成功");
  22.             String result = template.opsForValue().get("goods:001");
  23.             int total = result == null ? 0 : Integer.parseInt(result);
  24.             if (total > 0) {
  25.                 // 如果在此处需要调用其他微服务，处理时间较长。。。
  26.                 int realTotal = total - 1;
  27.                 template.opsForValue().set("goods:001", String.valueOf(realTotal));
  28.                 System.out.println("购买商品成功，库存还剩：" + realTotal + "件， 服务端口为8001");
  29.                 return "购买商品成功，库存还剩：" + realTotal + "件， 服务端口为8001";
  30.             } else {
  31.                 System.out.println("购买商品失败，服务端口为8001");
  32.             }
  33.             return "购买商品失败，服务端口为8001";
  34.         }finally {
  35.             // 谁加的锁，谁才能删除，使用Lua脚本，进行锁的删除
  36.  
  37.             Jedis jedis = null;
  38.             try{
  39.                 jedis = RedisUtils.getJedis();
  40.  
  41.                 String script = "if redis.call('get',KEYS[1]) == ARGV[1] " +
  42.                         "then " +
  43.                         "return redis.call('del',KEYS[1]) " +
  44.                         "else " +
  45.                         "   return 0 " +
  46.                         "end";
  47.  
  48.                 Object eval = jedis.eval(script, Collections.singletonList(REDIS_LOCK), Collections.singletonList(value));
  49.                 if("1".equals(eval.toString())){
  50.                     System.out.println("-----del redis lock ok....");
  51.                 }else{
  52.                     System.out.println("-----del redis lock error ....");
  53.                 }
  54.             }catch (Exception e){
  55.  
  56.             }finally {
  57.                 if(null != jedis){
  58.                     jedis.close();
  59.                 }
  60.             }
  61.         }
  62.     }
  63. }

3.5 方式五（改进方式四）

在方式四下，规定了谁上的锁，谁才能删除，并且解决了删除操作没有原子性问题。但还没有考虑缓存续命，以及Redis集群部署下，异步复制造成的锁丢失：主节点没来得及把刚刚set进来这条数据给从节点，就挂了。所以直接上RedLock的Redisson落地实现。

  1. @RestController
  2. public class IndexController8 {
  3.  
  4.     public static final String REDIS_LOCK = "lock";
  5.  
  6.     @Autowired
  7.     StringRedisTemplate template;
  8.  
  9.     @Autowired
  10.     Redisson redisson;
  11.  
  12.     @RequestMapping("/buy8")
  13.     public String index(){
  14.  
  15.         RLock lock = redisson.getLock(REDIS_LOCK);
  16.         lock.lock();
  17.  
  18.         // 每个人进来先要进行加锁，key值为"lock"
  19.         String value = UUID.randomUUID().toString().replace("-","");
  20.         try{
  21.             String result = template.opsForValue().get("goods:001");
  22.             int total = result == null ? 0 : Integer.parseInt(result);
  23.             if (total > 0) {
  24.                 // 如果在此处需要调用其他微服务，处理时间较长。。。
  25.                 int realTotal = total - 1;
  26.                 template.opsForValue().set("goods:001", String.valueOf(realTotal));
  27.                 System.out.println("购买商品成功，库存还剩：" + realTotal + "件， 服务端口为8001");
  28.                 return "购买商品成功，库存还剩：" + realTotal + "件， 服务端口为8001";
  29.             } else {
  30.                 System.out.println("购买商品失败，服务端口为8001");
  31.             }
  32.             return "购买商品失败，服务端口为8001";
  33.         }finally {
  34.             if(lock.isLocked() && lock.isHeldByCurrentThread()){
  35.                 lock.unlock();
  36.             }
  37.         }
  38.     }
  39. }

到此这篇关于Redis实现分布式锁方法详细的文章就介绍到这了 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/从前慢现在也慢/article/detail/696686
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号