spring 集成Redisson,实现分布式锁

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

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

## 0、pom.xml ##

<dependency>
          <groupId>redis.clients</groupId>
          <artifactId>jedis</artifactId>
          <version>2.6.0</version>
        </dependency>
        
        <dependency>
          <groupId>redis.clients</groupId>
          <artifactId>jedis</artifactId>
          <version>2.6.0</version>
        </dependency>
    
        <dependency>
          <groupId>org.projectlombok</groupId>
          <artifactId>lombok</artifactId>
          <version>1.16.18</version>
        </dependency>
        
        <dependency>
          <groupId>org.redisson</groupId>
          <artifactId>redisson</artifactId>
          <version>2.9.0</version>
        </dependency>
        
        <dependency>
          <groupId>com.fasterxml.jackson.dataformat</groupId>
          <artifactId>jackson-dataformat-avro</artifactId>
          <version>2.9.0</version>
        </dependency>

## 1、redis.properties ##

#redis config start
    
    redis1.ip=127.0.0.1
    redis1.port=6379
    
    redis2.ip=127.0.0.1
    redis2.port=6380
    
    
    #最大连接数
    redis.max.total=20
    
    #最大空闲数
    redis.max.idle=10
    
    #最小空闲数
    redis.min.idle=2
    
    #从jedis连接池获取连接时，校验并返回可用的连接
    redis.test.borrow=true
    
    #把连接放回jedis连接池时，校验并返回可用的连接
    redis.test.return=false
    
    
    #redis config end
    
    #closeOrderTaskTime start
    
    close.order.task.time.hour=2
    
    #毫秒数
    lock.timeout=5000
    
    #closeOrderTaskTime end

## 2、RedissonManager（redisson配置类） ##

package com.jack.common;
    
    import com.jack.util.PropertiesUtil;
    import lombok.extern.slf4j.Slf4j;
    import org.redisson.Redisson;
    import org.redisson.config.Config;
    import org.springframework.stereotype.Component;
    
    import javax.annotation.PostConstruct;
    
    /** * Created by jack */
    @Component
    @Slf4j
    public class RedissonManager { 
    
        private Config config = new Config();
    
        private Redisson redisson = null;
    
        public Redisson getRedisson() { 
            return redisson;
        }
    
        private static String redis1Ip = PropertiesUtil.getProperty("redis1.ip");
        private static Integer redis1Port = Integer.parseInt(PropertiesUtil.getProperty("redis1.port"));
        private static String redis2Ip = PropertiesUtil.getProperty("redis2.ip");
        private static Integer redis2Port = Integer.parseInt(PropertiesUtil.getProperty("redis2.port"));
    
        @PostConstruct
        private void init(){ 
            try { 
                config.useSingleServer().setAddress(new StringBuilder().append(redis1Ip).append(":").append(redis1Port).toString());
    
                redisson = (Redisson) Redisson.create(config);
    
                log.info("初始化Redisson结束");
            } catch (Exception e) { 
                log.error("redisson init error",e);
            }
        }
    
    }

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

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

package com.jack.task;
    
    import com.jack.common.Const;
    import com.jack.common.RedissonManager;
    import com.jack.service.IOrderService;
    import com.jack.util.PropertiesUtil;
    import com.jack.util.RedisShardedPoolUtil;
    import lombok.extern.slf4j.Slf4j;
    import org.apache.commons.lang.StringUtils;
    import org.redisson.api.RLock;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.scheduling.annotation.Scheduled;
    import org.springframework.stereotype.Component;
    
    import javax.annotation.PreDestroy;
    import java.util.concurrent.TimeUnit;
    
    /** * Created by jack */
    @Component
    @Slf4j
    public class CloseOrderTask { 
    
        @Autowired
        private IOrderService iOrderService;
    
        @Autowired
        private RedissonManager redissonManager;
    
        @PreDestroy
        public void delLock(){ 
            RedisShardedPoolUtil.del(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
    
        }
    
    // @Scheduled(cron="0 */1 * * * ?")//每1分钟(每个1分钟的整数倍)
        public void closeOrderTaskV1(){ 
            log.info("关闭订单定时任务启动");
            int hour = Integer.parseInt(PropertiesUtil.getProperty("close.order.task.time.hour","2"));
    // iOrderService.closeOrder(hour);
            log.info("关闭订单定时任务结束");
        }
    
    // @Scheduled(cron="0 */1 * * * ?")
        public void closeOrderTaskV2(){ 
            log.info("关闭订单定时任务启动");
            long lockTimeout = Long.parseLong(PropertiesUtil.getProperty("lock.timeout","5000"));
    
            Long setnxResult = RedisShardedPoolUtil.setnx(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK,String.valueOf(System.currentTimeMillis()+lockTimeout));
            if(setnxResult != null && setnxResult.intValue() == 1){ 
                //如果返回值是1，代表设置成功，获取锁
                closeOrder(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
            }else{ 
                log.info("没有获得分布式锁:{}",Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
            }
            log.info("关闭订单定时任务结束");
        }
    
        //@Scheduled(cron="0 */1 * * * ?")
        public void closeOrderTaskV3(){ 
            log.info("关闭订单定时任务启动");
            long lockTimeout = Long.parseLong(PropertiesUtil.getProperty("lock.timeout","5000"));
            Long setnxResult = RedisShardedPoolUtil.setnx(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK,String.valueOf(System.currentTimeMillis()+lockTimeout));
            if(setnxResult != null && setnxResult.intValue() == 1){ 
                closeOrder(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
            }else{ 
                //未获取到锁，继续判断，判断时间戳，看是否可以重置并获取到锁
                String lockValueStr = RedisShardedPoolUtil.get(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
                if(lockValueStr != null && System.currentTimeMillis() > Long.parseLong(lockValueStr)){ 
                    String getSetResult = RedisShardedPoolUtil.getSet(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK,String.valueOf(System.currentTimeMillis()+lockTimeout));
                    //再次用当前时间戳getset。
                    //返回给定的key的旧值，->旧值判断，是否可以获取锁
                    //当key没有旧值时，即key不存在时，返回nil ->获取锁
                    //这里我们set了一个新的value值，获取旧的值。
                    if(getSetResult == null || (getSetResult != null && StringUtils.equals(lockValueStr,getSetResult))){ 
                        //真正获取到锁
                        closeOrder(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
                    }else{ 
                        log.info("没有获取到分布式锁:{}",Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
                    }
                }else{ 
                    log.info("没有获取到分布式锁:{}",Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
                }
            }
            log.info("关闭订单定时任务结束");
        }
    
        @Scheduled(cron="0 */1 * * * ?")
        public void closeOrderTaskV4(){ 
            RLock lock = redissonManager.getRedisson().getLock(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
            boolean getLock = false;
            try { 
                if(getLock = lock.tryLock(0,50, TimeUnit.SECONDS)){ 
                    log.info("Redisson获取到分布式锁:{},ThreadName:{}",Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK,Thread.currentThread().getName());
                    int hour = Integer.parseInt(PropertiesUtil.getProperty("close.order.task.time.hour","2"));
    // iOrderService.closeOrder(hour);
                }else{ 
                    log.info("Redisson没有获取到分布式锁:{},ThreadName:{}",Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK,Thread.currentThread().getName());
                }
            } catch (InterruptedException e) { 
                log.error("Redisson分布式锁获取异常",e);
            } finally { 
                if(!getLock){ 
                    return;
                }
                lock.unlock();
                log.info("Redisson分布式锁释放锁");
            }
        }
    
    
    
    
        private void closeOrder(String lockName){ 
            RedisShardedPoolUtil.expire(lockName,5);//有效期50秒，防止死锁
            log.info("获取{},ThreadName:{}",Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK,Thread.currentThread().getName());
            int hour = Integer.parseInt(PropertiesUtil.getProperty("close.order.task.time.hour","2"));
            iOrderService.closeOrder(hour);
            RedisShardedPoolUtil.del(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
            log.info("释放{},ThreadName:{}",Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK,Thread.currentThread().getName());
            log.info("===============================");
        }
    
    }