上篇介绍了redis在集群环境下如何解决session共享的问题。今天来讲一下如何解决分布式锁的问题

什么是分布式锁?

分布式锁就是在多个服务器中,都来争夺某一资源。这时候我们肯定需要一把锁是不是 ,这个锁就是分布式锁,就算不是分布式,单机情况下,多个进程来争夺同一个资源,我们也要一把锁来控制先后顺序不是。分布式锁就是在多个服务器场景中来争夺相同的资源。打个比方,比如调度任务。

比如说,我们一个商城网站,要求每分钟要执行一个定时任务的操作,目的是把下单之后30分钟未付款的,把订单取消,然后把库存还原过去。因为是在多tomcat下,这个定时任务肯定会在同一时刻多个服务器都要执行操作。但是我们需要的是其中一个服务器操作就行了。这时候,就要用到我们的分布式锁啦。

我们在用redis来实现这个分布式锁的功能。我们会用到setnx方法,del方法,expire方法,getset方法  (这些方法的特性自己去百度下最好)

大致原理:我们利用setnx方法来设置一个key(写死的,以后都要用这个key获取锁),value的值(当前时间戳+锁的过期时间),如果设置成功返回1,说明我们已经获取锁,

然后再用expire方法设置key的有效期,因为肯定要有一个有效期的,不然你这一分钟已经执行完了,别人还想利用setnx获取锁,就一直获取不到,就造成了死锁。

设置好有效期之后,然后执行关单的业务逻辑,然后删除key。

其他服务器同时间操作,也是先setnx一下,结果发现别人已经获取到了锁,就返回失败0,然后就不执行关单操作。

上面的方法看似还可以,但是有一些bug,比如说服务器1setnx之后准备设置过期时间勒,服务器重启了,那是不是这个key就一直就消失不了了,那就造成了死锁。后面的永远都获取不到这个锁。细心的你肯定发现了,我们之前setnx的时候value还没用上呢?哈哈,现在就要用上了,我们来稍微改造一下。

我们之前的逻辑是如果获取锁,就执行设置过期时间,关单操作,没有获取锁就不执行关单操作。

我们现在改成如果没有获取锁,再进行一次判断,我们获取当前这个锁的value,因为key是我们写死的常量,我们可以从redis获取value时间戳

我们得到时间戳之后判断一下,这个时间戳和当前时间比那个大,如果当前时间大,说明这个锁已经过期了。因为我们上面已经说了,这个value的值就是当前时间+锁的过期时间

然后我们用getset方法重新设置锁的有效期,然后得到老得时间和再用单纯的get方法再获取老得时间,看是否相等,这点非常重要,因为相等说明中间没有其他线程获取到这个锁。可能有点迷,看代码就不迷了。ok   看代码吧

第一种会出现死锁的场景和第二种双重判断防止死锁的场景都有  注释很清楚

  1. /**
  2. * 可能出现死锁,虽然在执行close的时候有防死锁,但是还是会出现,继续演进V3
  3. */
  4. // @Scheduled(cron="0 */1 * * * ?")//每1分钟(每个1分钟的整数倍)
  5. public void closeOrderTaskV2() throws InterruptedException {
  6. long lockTimeout = Long.parseLong(PropertiesUtil.getProperty("lock.timeout","5000"));//锁5秒有效期
  7. //这个时间如何用呢,看下面。和时间戳结合起来用。
  8. Long setnxResult = RedisShardedPoolUtil.setnx(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK, String.valueOf(System.currentTimeMillis()+lockTimeout));
  9. if(setnxResult != null && setnxResult.intValue() == 1){
  10. //如果返回值是1,代表设置成功,获取锁
  11. closeOrder(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
  12. }else{
  13. log.info("没有获得分布式锁:{}",Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
  14. }
  15. }
  16.  
  17. /**
  18. * 防死锁之分布式锁
  19. * @throws InterruptedException
  20. */
  21. // @Scheduled(cron="0 */1 * * * ?")//每1分钟(每个1分钟的整数倍)
  22. public void closeOrderTaskV3() throws InterruptedException {
  23. //防死锁分布式锁
  24. long lockTimeout = Long.parseLong(PropertiesUtil.getProperty("lock.timeout","50000"));//锁50秒有效期
  25. //项目由于历史数据关单订单比较多,需要处理,初次用50s时间,后续改成5s即可.同时50s也为了讲课debug的时候时间长而设置。
  26. //大家可以根据实际情况,如果历史订单都处理完毕,或者在外部进行洗数据ok,这里的lock的时间应该设置小一些,例如1s 2s 3s 4s 5s就足够啦。
  27.  
  28. //这个时间如何用呢,看下面。和时间戳结合起来用。
  29. Long setnxResult = RedisShardedPoolUtil.setnx(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK, String.valueOf(System.currentTimeMillis()+lockTimeout));
  30. if(setnxResult != null && setnxResult.intValue() == 1){
  31. //如果返回值是1,代表设置成功,获取锁
  32. closeOrder(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
  33. }else{
  34. //如果setnxResult==null 或 setnxResult.intValue() ==0 即 != 1的时候
  35. //未获取到锁,继续判断,判断时间戳,看是否可以重置获取到锁
  36. String lockValueStr = RedisShardedPoolUtil.get(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
  37.  
  38. //如果lockValue不是空,并且当前时间大于锁的有效期,说明之前的lock的时间已超时,执行getset命令.
  39. if(lockValueStr != null && System.currentTimeMillis() > Long.parseLong(lockValueStr)){
  40. String getSetResult = RedisShardedPoolUtil.getSet(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK,String.valueOf(System.currentTimeMillis()+lockTimeout));
  41. //再次用当前时间戳getset,
  42. //返回给定 key 的旧值。 ->旧值判断,是否可以获取锁
  43. // 当 key 没有旧值时,即 key 不存在时,返回 nil 。 ->获取锁
  44. //这里我们set了一个新的value值,获取旧的值。
  45. if(getSetResult == null || (getSetResult !=null && StringUtils.equals(lockValueStr,getSetResult))){
  46. //获取到锁
  47. closeOrder(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
  48. }else{
  49. log.info("没有获得分布式锁:{}",Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
  50. }
  51. }else{
  52. log.info("没有获得分布式锁:{}",Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
  53. }
  54. }
  55. }
  56.  
  57. /**
  58. * Redisson分布式锁实现
  59. * @throws InterruptedException
  60. */
  61. // @Scheduled(cron="0 */1 * * * ?")//每1分钟(每个1分钟的整数倍)
  62. public void closeOrderTaskV4() throws InterruptedException {
  63. RLock lock = redissonManager.getRedisson().getLock(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
  64. boolean getLock = false;
  65. try {
  66. if(getLock = lock.tryLock(2,50, TimeUnit.SECONDS)){//trylock增加锁
  67. log.info("===获取{},ThreadName:{}",Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK,Thread.currentThread().getName());
  68. int hour = Integer.parseInt(PropertiesUtil.getProperty("close.order.task.time.hour","2"));
  69. iOrderService.closeOrder(hour);
  70. }else{
  71. log.info("===没有获得分布式锁:{}",Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
  72. }
  73. }finally {
  74. if(!getLock){
  75. return;
  76. }
  77. log.info("===释放分布式锁:{}",Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
  78. lock.unlock();
  79. }
  80. }
  81.  
  82. private void closeOrder(String lockName){
  83. // expire命令用于给该锁设定一个过期时间,用于防止线程crash,导致锁一直有效,从而导致死锁。
  84. RedisShardedPoolUtil.expire(lockName,50);//有效期50秒,防死锁
  85. log.info("获取{},ThreadName:{}",Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK,Thread.currentThread().getName());
  86. int hour = Integer.parseInt(PropertiesUtil.getProperty("close.order.task.time.hour","2"));
  87. iOrderService.closeOrder(hour);
  88. RedisShardedPoolUtil.del(lockName);//释放锁
  89. log.info("释放{},ThreadName:{}",Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK,Thread.currentThread().getName());
  90. log.info("=============================");
  91. }

#2018-04-10 21:57:01 再来填坑

再解释一下上面的逻辑,注意:上面有两个时间,一个key的过期时间,一个锁的过期时间。都是为了避免死锁的发生。

为毛要设置两个呢?任意一个都可以避免死锁啊?因为当我们setnx的时候是不能设置过期时间的,如果刚好setnx之后突然断电还没来得及设置key的过期时间,那岂不是会发生死锁。所以我们要再来个锁的过期时间来进一步判断。最根本原因是得到锁和设置key的过期时间没有同步,下面介绍一个redis分布式锁的框架。轻松解决分布式锁的问题,原理和上面一样,不过代码更为简单。不用过多的判断,框架已经帮我们做好了。

注意:Redisson这个框架不支持分布式就是只能一个redis,但是支持主从模式。和spring的session框架一样。切记

pom.xml     这个是Redisson所需的依赖

  1. <dependency>
  2. <groupId>org.redisson</groupId>
  3. <artifactId>redisson</artifactId>
  4. <version>2.9.0</version>
  5. </dependency>
  6. <!--com.fasterxml.jackson.dataformat.avro.PackageVersion-->
  7. <dependency>
  8. <groupId>com.fasterxml.jackson.dataformat</groupId>
  9. <artifactId>jackson-dataformat-avro</artifactId>
  10. <version>2.9.0</version>
  11. </dependency>

RedissonManager.java

  1. package com.mmall.common;
  2.  
  3. import com.mmall.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;
  8.  
  9. import javax.annotation.PostConstruct;
  10.  
  11. /**
  12. * Created by geely
  13. */
  14. @Slf4j
  15. @Component
  16. public class RedissonManager {
  17. //在redis环境没有搭建起来之前,这里先注释上,否则项目启动不起来。
  18.  
  19. private Config config = new Config();
  20.  
  21. private Redisson redisson = null;
  22.  
  23. private final static String redis1Ip = PropertiesUtil.getProperty("redis1.ip");
  24. private final static Integer redis1Port = Integer.parseInt(PropertiesUtil.getProperty("redis1.port"));
  25.  
  26. //注入到Spring容器的话,使用@PostConstruct或者静态块初始化,效果是一样的{}
  27.  
  28. @PostConstruct
  29. private void init() {
  30. try {
  31. //在redis环境没有搭建起来之前,这里先注释上,否则项目启动不起来。
  32.  
  33. ////127.0.0.1:6379
  34. config.useSingleServer().setAddress(new StringBuilder().append(redis1Ip).append(":").append(redis1Port).toString());
  35.  
  36. //单主模式
  37. // config.useMasterSlaveServers().setMasterAddress(new StringBuilder().append(redis1Ip).append(":").append(redis1Port).toString());
  38.  
  39. //主从模式
  40. // config.useMasterSlaveServers().setMasterAddress("10.211.55.6:6379").addSlaveAddress("10.211.55.6:6380");
  41.  
  42. // redisson = (Redisson) Redisson.create(config);
  43. log.info("初始化Redisson结束");
  44. } catch (Exception e) {
  45. log.error("redisson init error", e);
  46. }
  47. }
  48.  
  49. // {
  50. // init();
  51. // }
  52.  
  53. public Redisson getRedisson() {
  54. return redisson;
  55. }
  56.  
  57. }

下面是具体实现代码,原理一样,只不过简化操作。切记:一定要把tryLock的第一个参数等待获取锁的时间设置为0.有坑

  1. /**
  2. * Redisson分布式锁实现
  3. * @throws InterruptedException
  4. */
  5. // @Scheduled(cron="0 */1 * * * ?")//每1分钟(每个1分钟的整数倍)
  6. public void closeOrderTaskV4() throws InterruptedException {
  7. //意思是把Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK这个常量当成key
  8. RLock lock = redissonManager.getRedisson().getLock(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
  9. boolean getLock = false;
  10. try {
  11. if(getLock = lock.tryLock(2,50, TimeUnit.SECONDS)){//trylock试着获取锁,2的意思是等待获取锁的时间为2s,要设为0,不然会出现一些意想不到的错误,50的意思就是锁的过期时间(同样也是key的过期时间)
  12. log.info("===获取{},ThreadName:{}",Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK,Thread.currentThread().getName());
  13. int hour = Integer.parseInt(PropertiesUtil.getProperty("close.order.task.time.hour","2"));
  14. iOrderService.closeOrder(hour);
  15. }else{
  16. log.info("===没有获得分布式锁:{}",Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
  17. }
  18. }finally {
  19. if(!getLock){
  20. return;
  21. }
  22. log.info("===释放分布式锁:{}",Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
  23. lock.unlock();
  24. }
  25. }

ok,原生的方法有了,框架的也有了。点个赞吧。

在tomcat集群环境下redis实现分布式锁的更多相关文章

  1. Tomcat集群环境下session共享方案 通过memcached 方法实现

    对于web应用集群的技术实现而言,最大的难点就是:如何能在集群中的多个节点之间保持数据的一致性,会话(Session)信息是这些数据中最重要的一块.要实现这一点, 大体上有两种方式:一种是把所有Ses ...

  2. 【原创】Tomcat集群环境下对session进行外部缓存的方法(2)

    Session对象的持久化比较麻烦,虽然有序列化,但是并不确定Session对象中保存的其他信息是否可以序列化,这可能是网上很多解决方案摒弃此种做法的原因,网上的很多做法都是将Session中的att ...

  3. 【分布式缓存系列】集群环境下Redis分布式锁的正确姿势

    一.前言 在上一篇文章中,已经介绍了基于Redis实现分布式锁的正确姿势,但是上篇文章存在一定的缺陷——它加锁只作用在一个Redis节点上,如果通过sentinel保证高可用,如果master节点由于 ...

  4. 【原创】Tomcat集群环境下对session进行外部缓存的方法(1)

    BJJC网改版, 计划将应用部署在tomcat集群上,集群的部署方案为Apache+Tomcat6,连接件为mod_jk,其中开启了session复制和粘性session.计划节点数为3个. 到这,或 ...

  5. 分布式集群环境下,如何实现session共享五(spring-session+redis 实现session共享)

    这是分布式集群环境下,如何实现session共享系列的第五篇.在上一篇:分布式集群环境下,如何实现session共享四(部署项目测试)中,针对nginx不同的负载均衡策略:轮询.ip_hash方式,测 ...

  6. redis内存分配管理与集群环境下Session管理

    ##################内存管理############### 1.Redis的内存管理 .与memcache不同,没有实现自己的内存池 .在2..4以前,默认使用标准的内存分配函数(li ...

  7. redis 与java的连接 和集群环境下Session管理

    redis 的安装与设置开机自启(https://www.cnblogs.com/zhulina-917/p/11746993.html)  第一步: a) 搭建环境 引入 jedis jar包 co ...

  8. Redis集群环境下的键值空间监听事件实现方案

    一直想记录工作中遇到的问题和解决的方法,奈何没有找到一方乐土,最近经常反思,是否需要记录平时的点滴,后台还是决定下定决心记录一些,以便以后用到的时候找不着,实现这样的一个功能主要也是业务所需要的. 需 ...

  9. CAS服务器集群和客户端集群环境下的单点登录和单点注销解决方案

    CAS的集群环境,包括CAS的客户应用是集群环境,以及CAS服务本身是集群环境这两种情况.在集群环境下使用CAS,要解决两个问题,一是单点退出(注销)时,CAS如何将退出请求正确转发到用户sessio ...

随机推荐

  1. 小学四则运算APP 第一个冲刺 第八天

    团队成员:陈淑筠.杨家安.陈曦 团队选题:小学四则运算APP 第一次冲刺阶段时间:11.17~11.27 本次发布的是还未完成的功能二(选择题): ChoiceActivity.java: packa ...

  2. Mock.js的简单使用

    Mock.js 提供的种类有: 步骤: 首先安装:cnpm install mockjs 创建一个mock.js的文件,写好需要引入的数据格式 在main.js中引入mock.js文件: requir ...

  3. Ubuntu 服务器指南

    https://help.ubuntu.com/lts/serverguide/   Jabber Instant Messaging Server https://help.ubuntu.com/l ...

  4. mysql数据库优化大全

    转载:https://blog.csdn.net/weixin_38112233/article/details/79054661 数据库优化 sql语句优化 索引优化 加缓存 读写分离 分区 分布式 ...

  5. Java DateUtils 的实用

    Java DateUtils的实用可以很方便的对日期进行对年,月,日,时,分,秒的相加和相减,能很好的解决日期的运算 可以不用必须调用Oracle等数据库本地函数进行运算,相比之下更为简洁方便. pa ...

  6. PKUWC 2019&WC 2019爆零记

    PKUWC 2019&WC 2019爆零记 毕竟过了很久了,杂七杂八的东西就不写了,并且除成绩之外的内容不保证其正确性. Day1 T1:看到这道题很舒服啊,枚举top序算合法图的数量,状压D ...

  7. 有趣的线段树模板合集(线段树,最短/长路,单调栈,线段树合并,线段树分裂,树上差分,Tarjan-LCA,势能线段树,李超线段树)

    线段树分裂 以某个键值为中点将线段树分裂成左右两部分,应该类似Treap的分裂吧(我菜不会Treap).一般应用于区间排序. 方法很简单,就是把分裂之后的两棵树的重复的\(\log\)个节点新建出来, ...

  8. 自学Python6.4-内置模块(2)

    自学Python之路-Python基础+模块+面向对象自学Python之路-Python网络编程自学Python之路-Python并发编程+数据库+前端自学Python之路-django 自学Pyth ...

  9. 【AGC010D】Decrementing

    Solution 日常博弈论做不出来. 首先,数值全部为1的局面先手必败. 在接下来的过程中,我们只关注那些大于1的数值. 按照官方题解的思路,首先想一个简化版的问题:没有除的操作,其余相同.那么局面 ...

  10. JDK源码分析(5)Vector

    JDK版本 Vector简介 /** * The {@code Vector} class implements a growable array of * objects. Like an arra ...