利用redis的setIfAbsent()方法实现分布式锁

秒速五厘米 2023-09-30 22:22 29阅读 0赞

再集群环境中，存在定时任务多次执行，浪费资源，那么如何避免这种情况呢，下面就说明一下如何利用一个注解解决问题，利用切面配合redis可以简单实现分布式锁，解决定时任务重复执行的问题。直接上干货了，感觉不对的朋友勿喷，请划过。

实现逻辑和基本原理  
逻辑：  
1、每一次访问进来都先去获得redis 锁 如果获得到 则继续执行，如果获取不到 则直接返回  
2、redis 的key 设有过期时间 避免某个请求处理不当（或方法执行到一半宕机或网络原因）导致 redis key 不能正确释放 死锁  
3 在 finally 方法里进行手工释放锁  
基本原理（即有什么样的理论基础 才可以用redis做分布式锁）：  
1、setIfAbsent 即 setnx 当key不存在时设置成功，当key 存在时会设置失败  
2、redis设置key 和 设置过期时间 必须为原子性，即同时设置。否则在设置完key 后系统宕机 此时还没来得及设置过期时间 那么这个可以就成了永久的key了 就会产生死锁的情况

首先自定义一个注解

@Retention(RetentionPolicy.RUNTIME)
    @Target({ElementType.METHOD})
    @Documented
    public @interface RedisLock {
        String lockPrefix() default "";
    
        String lockKey() default "";
    
        //是否使用自定义过期时间,false->配置文件获取;true->自己指定过期时间
        boolean expireConfig() default true;
    
        long timeOut() default 30;
    
        TimeUnit timeUnit() default TimeUnit.SECONDS;
    }

然后定义一个切面，

package com.mes.material.annotation.redisLock;
    
    import lombok.extern.slf4j.Slf4j;
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.Around;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Pointcut;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.stereotype.Component;
    
    import java.lang.reflect.Method;
    import java.util.HashMap;
    import java.util.Map;
    import java.util.concurrent.TimeUnit;
    
    
    @Aspect
    @Component
    @Slf4j
    public class RedisLockAspect {
        private static final Integer Max_RETRY_COUNT = 3;
        private static final String LOCK_PRE_FIX = "lockPreFix";
        private static final String LOCK_KEY = "lockKey";
        private static final String TIME_OUT = "timeOut";
        private static final String EXPIRE_CONFIG = "expireConfig";
    
        @Value("${schedule.expire}")
        private long timeOut;
    
        @Autowired
        private RedisTemplate redisTemplate;
    
        @Pointcut("@annotation(com.mes.material.annotation.redisLock.RedisLock)")
        public void redisLockAspect() {
        }
    
        @Around("redisLockAspect()")
        public void lockAroundAction(ProceedingJoinPoint proceeding) throws Exception {
    
            //获取注解中的参数
            Map<String, Object> annotationArgs = this.getAnnotationArgs(proceeding);
            String lockPrefix = (String) annotationArgs.get(LOCK_PRE_FIX);
            String key = (String) annotationArgs.get(LOCK_KEY);
            long expire = (long) annotationArgs.get(TIME_OUT);
            boolean expireConfig = (boolean) annotationArgs.get(EXPIRE_CONFIG);
            //分布式锁
            boolean lock = false;
            long expireTime = 0L;
            try {
    
                    //设置过期时间
                    if (expireConfig) {
                        expireTime  = expire;
                    } else {
                        expireTime = timeOut;
                    }
    //1.占分布式锁的同时 给锁设置过期时间。
    //这是一个原子性操作，要么同时成功，要么同时失败。
                //如果返回true，说明key不存在，获取到锁
                lock = redisTemplate.opsForValue().setIfAbsent(key, lockPrefix,expireTime, TimeUnit.SECONDS);
                log.info("是否获取到锁:" + lock);
                if (lock) {
                    log.info("获取到锁，开启定时任务！");
    
                    proceeding.proceed();
                } else {
                    log.info("其他系统正在执行此项任务");
                    return;
                }
            } catch (Exception e) {
                e.printStackTrace();
            } catch (Throwable throwable) {
                throw new RuntimeException("分布式锁执行发生异常" + throwable.getMessage(), throwable);
            }
        }
    
        /**
         * 获取锁参数
         *
         * @param proceeding
         * @return
         */
        private Map<String, Object> getAnnotationArgs(ProceedingJoinPoint proceeding) {
            Class target = proceeding.getTarget().getClass();
            Method[] methods = target.getMethods();
            String methodName = proceeding.getSignature().getName();
            for (Method method : methods) {
                if (method.getName().equals(methodName)) {
                    Map<String, Object> result = new HashMap<String, Object>();
                    RedisLock redisLock = method.getAnnotation(RedisLock.class);
                    result.put(LOCK_PRE_FIX, redisLock.lockPrefix());
                    result.put(LOCK_KEY, redisLock.lockKey());
                    result.put(TIME_OUT, redisLock.timeUnit().toSeconds(redisLock.timeOut()));
                    result.put(EXPIRE_CONFIG, redisLock.expireConfig());
                    return result;
                }
            }
            return null;
        }
    
    }

到此一个自定义注解实现redis分布式锁的代码就完成了，下面就是如何利用这个注解了

这里面需要注意，占分布式锁的同时 给锁设置过期时间。是为了保证原子性操作，要么同时成功，要么同时失败。这么做是为了防止死锁。

@RedisLock

@Component
    @Slf4j
    public class MaterialStatisticsTask {
    
        private static final String lock_key = "material_statistics_task";
    
        private static final String lock_value = "material_statistics_task-ZKAW-YQS";
    
        @Autowired
        private IMaterialStatisticsServices materialStatisticsServices;
    
        // 每月1号0点30分执行
        @Scheduled(cron = "${schedule.statisticsCron}")
        @RedisLock(lockPrefix = lock_value, lockKey = lock_key, expireConfig = false)
        public void doTask() {
            try {
                log.info("物资收发存统计定时任务！");
                MaterialStatisticsVo materialStatisticsVo = new MaterialStatisticsVo();
                materialStatisticsServices.materialStatistics(materialStatisticsVo);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

这样就可以利用注解的形式实现分布式锁，这样每次需要用的时候直接一个注解就搞定了，避免了每次都要写很长的代码。

以上说的是redis实现分布式锁，那么加锁成功如何主动释放锁呢？

在解锁时要考虑到原子性，针对原子性操作，就可以考虑利用lua脚本去释放锁

String uuid = UuID.randomUuID() .tostring();
     /*================================释放锁===================================*/
                // 定义一个lua脚本
                String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
                // 创建对象
                DefaultRedisScript<Long> redisScript = new DefaultRedisScript();
                // 设置lua脚本
                redisScript.setScriptText(script);
                //设置lua脚本返回类型为Long
                redisScript.setResultType(Long.class);
                // redis调用lua脚本
                redisTemplate.execute(redisScript, Arrays.asList("lock"),uuid);