spring 集成Redisson,实现分布式锁

向右看齐 2023-02-13 05:45 95阅读 0赞

使用的业务场景：

例如：电商项目的分布式系统，需要定时关闭超时的订单信息，我们会利用spring的调度定时去处理，但由于是分布式的会互相竞争资源，所以需要用到分布式锁，让每个进程之间互相去竞争锁，获得锁的进程才去执行任务。这样就能保证事务的原子性，代码的健壮性。

0、pom.xml

  1. <dependency>
  2.       <groupId>redis.clients</groupId>
  3.       <artifactId>jedis</artifactId>
  4.       <version>2.6.0</version>
  5.     </dependency>
  7.     <dependency>
  8.       <groupId>redis.clients</groupId>
  9.       <artifactId>jedis</artifactId>
  10.       <version>2.6.0</version>
  11.     </dependency>
  13.     <dependency>
  14.       <groupId>org.projectlombok</groupId>
  15.       <artifactId>lombok</artifactId>
  16.       <version>1.16.18</version>
  17.     </dependency>
  19.     <dependency>
  20.       <groupId>org.redisson</groupId>
  21.       <artifactId>redisson</artifactId>
  22.       <version>2.9.0</version>
  23.     </dependency>
  25.     <dependency>
  26.       <groupId>com.fasterxml.jackson.dataformat</groupId>
  27.       <artifactId>jackson-dataformat-avro</artifactId>
  28.       <version>2.9.0</version>
  29.     </dependency>

1、redis.properties

  1. #redis config start
  3. redis1.ip=127.0.0.1
  4. redis1.port=6379
  6. redis2.ip=127.0.0.1
  7. redis2.port=6380
  10. #最大连接数
  11. redis.max.total=20
  13. #最大空闲数
  14. redis.max.idle=10
  16. #最小空闲数
  17. redis.min.idle=2
  19. #从jedis连接池获取连接时，校验并返回可用的连接
  20. redis.test.borrow=true
  22. #把连接放回jedis连接池时，校验并返回可用的连接
  23. redis.test.return=false
  26. #redis config end
  28. #closeOrderTaskTime start
  30. close.order.task.time.hour=2
  32. #毫秒数
  33. lock.timeout=5000
  35. #closeOrderTaskTime end

2、RedissonManager（redisson配置类）

  1. package com.jack.common;
  3. import com.jack.util.PropertiesUtil;
  4. import lombok.extern.slf4j.Slf4j;
  5. import org.redisson.Redisson;
  6. import org.redisson.config.Config;
  7. import org.springframework.stereotype.Component;
  9. import javax.annotation.PostConstruct;
  11. /** * Created by jack */
  12. @Component
  13. @Slf4j
  14. public class RedissonManager { 
  16.     private Config config = new Config();
  18.     private Redisson redisson = null;
  20.     public Redisson getRedisson() { 
  21.         return redisson;
  22.     }
  24.     private static String redis1Ip = PropertiesUtil.getProperty("redis1.ip");
  25.     private static Integer redis1Port = Integer.parseInt(PropertiesUtil.getProperty("redis1.port"));
  26.     private static String redis2Ip = PropertiesUtil.getProperty("redis2.ip");
  27.     private static Integer redis2Port = Integer.parseInt(PropertiesUtil.getProperty("redis2.port"));
  29.     @PostConstruct
  30.     private void init(){ 
  31.         try { 
  32.             config.useSingleServer().setAddress(new StringBuilder().append(redis1Ip).append(":").append(redis1Port).toString());
  34.             redisson = (Redisson) Redisson.create(config);
  36.             log.info("初始化Redisson结束");
  37.         } catch (Exception e) { 
  38.             log.error("redisson init error",e);
  39.         }
  40.     }
  42. }

3、CloseOrderTask（关闭订单的定时任务类）

其中closeOrderTaskV4是利用了redisson的分布式锁。
closeOrderTaskV3是用的原生手动方法。
closeOrderTaskV2和closeOrderTaskV1是有缺陷的方法。

  1. package com.jack.task;
  3. import com.jack.common.Const;
  4. import com.jack.common.RedissonManager;
  5. import com.jack.service.IOrderService;
  6. import com.jack.util.PropertiesUtil;
  7. import com.jack.util.RedisShardedPoolUtil;
  8. import lombok.extern.slf4j.Slf4j;
  9. import org.apache.commons.lang.StringUtils;
  10. import org.redisson.api.RLock;
  11. import org.springframework.beans.factory.annotation.Autowired;
  12. import org.springframework.scheduling.annotation.Scheduled;
  13. import org.springframework.stereotype.Component;
  15. import javax.annotation.PreDestroy;
  16. import java.util.concurrent.TimeUnit;
  18. /** * Created by jack */
  19. @Component
  20. @Slf4j
  21. public class CloseOrderTask { 
  23.     @Autowired
  24.     private IOrderService iOrderService;
  26.     @Autowired
  27.     private RedissonManager redissonManager;
  29.     @PreDestroy
  30.     public void delLock(){ 
  31.         RedisShardedPoolUtil.del(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
  33.     }
  35. // @Scheduled(cron="0 */1 * * * ?")//每1分钟(每个1分钟的整数倍)
  36.     public void closeOrderTaskV1(){ 
  37.         log.info("关闭订单定时任务启动");
  38.         int hour = Integer.parseInt(PropertiesUtil.getProperty("close.order.task.time.hour","2"));
  39. // iOrderService.closeOrder(hour);
  40.         log.info("关闭订单定时任务结束");
  41.     }
  43. // @Scheduled(cron="0 */1 * * * ?")
  44.     public void closeOrderTaskV2(){ 
  45.         log.info("关闭订单定时任务启动");
  46.         long lockTimeout = Long.parseLong(PropertiesUtil.getProperty("lock.timeout","5000"));
  48.         Long setnxResult = RedisShardedPoolUtil.setnx(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK,String.valueOf(System.currentTimeMillis()+lockTimeout));
  49.         if(setnxResult != null && setnxResult.intValue() == 1){ 
  50.             //如果返回值是1，代表设置成功，获取锁
  51.             closeOrder(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
  52.         }else{ 
  53.             log.info("没有获得分布式锁:{}",Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
  54.         }
  55.         log.info("关闭订单定时任务结束");
  56.     }
  58.     //@Scheduled(cron="0 */1 * * * ?")
  59.     public void closeOrderTaskV3(){ 
  60.         log.info("关闭订单定时任务启动");
  61.         long lockTimeout = Long.parseLong(PropertiesUtil.getProperty("lock.timeout","5000"));
  62.         Long setnxResult = RedisShardedPoolUtil.setnx(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK,String.valueOf(System.currentTimeMillis()+lockTimeout));
  63.         if(setnxResult != null && setnxResult.intValue() == 1){ 
  64.             closeOrder(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
  65.         }else{ 
  66.             //未获取到锁，继续判断，判断时间戳，看是否可以重置并获取到锁
  67.             String lockValueStr = RedisShardedPoolUtil.get(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
  68.             if(lockValueStr != null && System.currentTimeMillis() > Long.parseLong(lockValueStr)){ 
  69.                 String getSetResult = RedisShardedPoolUtil.getSet(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK,String.valueOf(System.currentTimeMillis()+lockTimeout));
  70.                 //再次用当前时间戳getset。
  71.                 //返回给定的key的旧值，->旧值判断，是否可以获取锁
  72.                 //当key没有旧值时，即key不存在时，返回nil ->获取锁
  73.                 //这里我们set了一个新的value值，获取旧的值。
  74.                 if(getSetResult == null || (getSetResult != null && StringUtils.equals(lockValueStr,getSetResult))){ 
  75.                     //真正获取到锁
  76.                     closeOrder(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
  77.                 }else{ 
  78.                     log.info("没有获取到分布式锁:{}",Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
  79.                 }
  80.             }else{ 
  81.                 log.info("没有获取到分布式锁:{}",Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
  82.             }
  83.         }
  84.         log.info("关闭订单定时任务结束");
  85.     }
  87.     @Scheduled(cron="0 */1 * * * ?")
  88.     public void closeOrderTaskV4(){ 
  89.         RLock lock = redissonManager.getRedisson().getLock(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
  90.         boolean getLock = false;
  91.         try { 
  92.             if(getLock = lock.tryLock(0,50, TimeUnit.SECONDS)){ 
  93.                 log.info("Redisson获取到分布式锁:{},ThreadName:{}",Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK,Thread.currentThread().getName());
  94.                 int hour = Integer.parseInt(PropertiesUtil.getProperty("close.order.task.time.hour","2"));
  95. // iOrderService.closeOrder(hour);
  96.             }else{ 
  97.                 log.info("Redisson没有获取到分布式锁:{},ThreadName:{}",Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK,Thread.currentThread().getName());
  98.             }
  99.         } catch (InterruptedException e) { 
  100.             log.error("Redisson分布式锁获取异常",e);
  101.         } finally { 
  102.             if(!getLock){ 
  103.                 return;
  104.             }
  105.             lock.unlock();
  106.             log.info("Redisson分布式锁释放锁");
  107.         }
  108.     }
  113.     private void closeOrder(String lockName){ 
  114.         RedisShardedPoolUtil.expire(lockName,5);//有效期50秒，防止死锁
  115.         log.info("获取{},ThreadName:{}",Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK,Thread.currentThread().getName());
  116.         int hour = Integer.parseInt(PropertiesUtil.getProperty("close.order.task.time.hour","2"));
  117.         iOrderService.closeOrder(hour);
  118.         RedisShardedPoolUtil.del(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
  119.         log.info("释放{},ThreadName:{}",Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK,Thread.currentThread().getName());
  120.         log.info("===============================");
  121.     }
  123. }

发表评论

表情：
评论列表 （有 0 条评论，95人围观）

还没有评论，来说两句吧...

相关阅读