Redis分布式锁

最新推荐文章于 2024-09-20 15:32:13 发布

chainoflove

最新推荐文章于 2024-09-20 15:32:13 发布

阅读量40

点赞数

文章标签： java 开发语言

本文链接：https://blog.csdn.net/u012000503/article/details/131269880

版权

文章介绍了如何利用Redis的分布式锁机制解决在多服务器环境下定时任务重复执行的问题。LockUtils类提供了加锁和解锁的方法，通过设置锁的超时时间和检查锁是否过期来避免死锁。TestTask类展示了在执行定时任务前先尝试获取锁，只有获取到锁才会执行任务，确保同一时刻只有一个服务器执行该任务。

摘要由CSDN通过智能技术生成

定时任务模块部署在两台服务器，执行任务时，每次都是执行两遍。

廖师兄的工具类：

@Slf4j
@Component
public class LockUtils {

    @Autowired
    StringRedisTemplate redisTemplate;

    /**
     *@Description
     *@Date 14:10 2018/6/17
     *@Param value:当前时间+超时时间
     *@return
     **/
    public  boolean lock(String key,String value){
        redisTemplate = SpringUtils.getBean("stringRedisTemplate");
        if (redisTemplate.opsForValue().setIfAbsent(key,value)){
            return true;
        }
        //下面代码解决了 死锁问题 和 保证只有一个线程拿锁。
        /**1.死锁 。当相关代码之前上锁后，如果执行代码的过程中抛错了，
         那么就会出现没有解锁的问题，后续线程无法获得锁，也就出现了死锁的问题。
         而以下代码后有返回true的可能，也就解决了死锁问题。
         */
        /**2.保证只有一个线程拿锁。比如两个线程同时进入下面代码，并且其value都为B，currentValue = A。
         一条代码只可能一个线程执行。
         当第一个线程执行时，oldvalue = A，如果符合if条件成功拿锁。
         当第二个执行时oldValue就已经是B了，所以保证了只有一个线程拿锁。
         */
        String currentValue = redisTemplate.opsForValue().get(key);
        //如果锁过期
        if (!StringUtils.isEmpty(currentValue) && Long.parseLong(currentValue) < System.currentTimeMillis()){
            //获取上一个锁的时间
            String oldValue = redisTemplate.opsForValue().getAndSet(key,value);
            if (!StringUtils.isEmpty(oldValue) && oldValue.equals(currentValue)){
                return true;
            }
        }

        return false;
    }

    /**
     *@Description 解锁
     *@Date 14:25 2018/6/17
     *@Param
     *@return
     **/
    public void delete(String key,String value){
        redisTemplate = SpringUtils.getBean("stringRedisTemplate");
        try{
            String currentValue = redisTemplate.opsForValue().get(key);
            if (!StringUtils.isEmpty(currentValue) && currentValue.equals(value)){
                redisTemplate.opsForValue().getOperations().delete(key);
            }
        }catch (Exception e){
            log.error("【redis分布式锁】解锁异常，{}",e);
        }
    }

}

@Slf4j
@Component
public class TestTask implements Job {

    @Autowired
    LockUtils lockUtil;
//    private LockUtils lockUtil = new LockUtils();

//    @CacheLock(lockedKey = "TEST_TASK",lockedValue = "TestTask",expireTime =120L)
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {

        LockUtils lockUtil = SpringUtils.getBean(LockUtils.class);
        String key="TEST_TASK_NEW";
        boolean lock = false;
        long l = System.currentTimeMillis() + 4000;
        String value = String.valueOf(l);
        try {
            //这里利用redis的分布式锁机制控制集群环境下定时器重复执行的问题
            log.info("========================test=========================");
            lock = lockUtil.lock(key,value);
            log.info("是否获取到锁:" + lock);
            if (lock) {
                try {
                    log.info("【测试数据】定时任务启动：执行了~");
                    log.info("【测试数据】【定时任务】 -> 成功，任务结束。");
                }catch (Exception e){
                    log.error("【测试数据】【定时任务】 -> 失败:{}",e.getMessage());
                    throw new JobExecutionException("【测试数据】【定时任务】 -> 接口调用失败，原因：" + e.getMessage());
                }
            } else {
                log.info("没有获取到锁，不执行任务!");
            }
        }finally {
            if (lock) {
                lockUtil.delete(key,value);
                log.info("任务结束，释放锁!");
            } else {
                log.info("没有获取到锁，无需释放锁!");
            }
        }
    }
}