Redis分布式锁：基于AOP和Redis实现的简易版分布式锁

时间 2019-11-07

原文原文链接

原文首发于简书，本文将《基于AOP和Redis实现的简易版分布式锁》和《基于AOP和Redis实现的简易版分布式锁（二）》两篇文章进行了整合，修改了部份内容。redis

平时在项目中常常会遇到并发问题，理论上有些方法只应该被调用一次，但因为并发而被重复调用，致使出现系统问题。而在咱们的项目中，最容易发生这种状况的是，推送消息的服务。不管是短信仍是app推送，或者是公众号的推送，由于并发问题而致使的重复推送，确定是不被容许的。数据库

因此我准备经过分布式锁去解决这个问题。express

分布式锁通常解决以下两类问题：缓存

一、效率性问题，好比重复发短信，重复生成一样的订单等。bash

二、正确性问题，好比在某一个请求扣款的同时不容许其余请求同时去扣款。并发

固然，题目中写了简易版是由于，此次的分布式锁只准备解决效率性的问题，而不解决正确性的问题。app

之因此基于Redis，是由于Redis做为一款基本上互联网公司都会必备的缓存数据库，简单好用，入门门槛较低。dom

而基于AOP实现，是由于用注解方式侵入性更低，基本上不须要修改原生代码，只须要加注解就行。分布式

以下是简易版的分布式锁的实现方式：ui

首先咱们须要1个注解，用于方法的LockAnnotation

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD, ElementType.TYPE})
public @interface LockAnnotation {

    /**
     * 加锁的key的前缀
     *
     * @return
     */
    String lockField() default "";
    
    /**
     * 加锁的key的值
     * @return
     */
    String lockKey() default "";

    /**
     * 锁自动释放时间，单位s
     *
     * @return
     */
    int lockTime() default 3;

    /**
     * 获取锁的最大等待时间，单位s，默认不等待，0即为快速失败
     *
     * @return
     */
    int waitTime() default 0;
}

复制代码

LockAnnotation用于加在须要分布式锁的方法上，代表这是一个须要加分布式锁的方法，来引入切面，lockField用于redis的key的前缀识别，lockKey是用于明确redis的key，经过SpEL语法实现，lockTime是防止死锁而添加的锁的默认失效时间，waitTime是为了让锁获取失败时能够进行等待则不只仅是快速失败。

最后是切面的实现LockAspect

@Component
@Aspect
public class LockAspect {

    private static Logger logger = LoggerFactory.getLogger(LockAspect.class);

    private static final String REDIS_SET_SUCCESS = "OK";

    @Resource
    private CacheUtils cacheUtils;

    @Around("@annotation(lockAnnotation)")
    public Object lockAround(ProceedingJoinPoint joinPoint, LockAnnotation lockAnnotation) throws Throwable {
        ExpressionParser parser = new SpelExpressionParser();
        LocalVariableTableParameterNameDiscoverer discoverer = new LocalVariableTableParameterNameDiscoverer();
        EvaluationContext context = new StandardEvaluationContext();

        Object[] args = joinPoint.getArgs();
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();

        String[] params = discoverer.getParameterNames(signature.getMethod());
        for (int len = 0; len < params.length; len++) {
            context.setVariable(params[len], args[len]);
        }
        Expression expression = parser.parseExpression(lockAnnotation.lockKey());
        String lockKey = expression.getValue(context, String.class);
        int lockTime = lockAnnotation.lockTime() > 1 ? lockAnnotation.lockTime() : 1;
        int waitTime = lockAnnotation.waitTime() > 0 ? lockAnnotation.waitTime() : 0;
        int lockTime = lockAnnotation.lockTime();
        String randomValue = UUID.randomUUID().toString();
        long startTime = System.currentTimeMillis();
        long endTime = System.currentTimeMillis() + waitTime * 1000;
        try {
            do {
                if (this.getLock(lockField, lockKey, randomValue, lockTime)) {
                    if (logger.isInfoEnabled()) {
                        logger.info("得到锁成功,方法名为{},参数为{}", joinPoint.getSignature(),
                                String.join("-", Lists.newArrayList(args).stream().map(obj -> JSONObject.toJSONString(ObjectUtils.defaultIfNull(obj, "null")))
                                        .collect(Collectors.toList())));
                    }
                    Object returnObject = joinPoint.proceed(args);
                    return returnObject;
                }
                int sleepTime = Math.min(300, waitTime * 100);
                if (logger.isDebugEnabled()) {
                    logger.debug("当前没法得到锁,本次等待{}ms,方法名为{},参数为{}", sleepTime, joinPoint.getSignature(),
                            String.join("-", Lists.newArrayList(args).stream().map(obj -> JSONObject.toJSONString(ObjectUtils.defaultIfNull(obj, "null")))
                                    .collect(Collectors.toList())));
                }
                Thread.sleep(sleepTime);
            } while (System.currentTimeMillis() <= endTime);
            if (logger.isInfoEnabled()) {
                logger.info("得到锁失败,放弃等待,以前共等待{}ms,方法将不执行,方法名为{},参数为{}", System.currentTimeMillis() - startTime, joinPoint.getSignature()
                        , String.join("-", Lists.newArrayList(args).stream().map(Object::toString)
                                .collect(Collectors.toList())));
            }
            return null;
        } finally {
            cacheUtils.delLock(lockField, lockKey, randomValue);
        }
    }
}
复制代码

其中setLock是经过Redis的set指令实现的，其中[NX|XX]选择NX，而后设置过时时间。而delLock是经过Redis的eval指令去执行lua脚本实现的，其中script代码以下：

String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
复制代码

以上获取锁和释放锁的过程通过一次改良，本来不太完美的的代码以下：

try {
	if (cacheUtils.incr(lockField, lockKey) > 1) {
		if (logger.isDebugEnabled()) {
			logger.debug("没法得到锁,方法名为{},参数为{}", joinPoint.getSignature(), String.join("-", Lists.newArrayList(args).stream().map(Object::toString).collect(Collectors.toList())));
        }
		return null;
    }
	cacheUtils.expireKey(lockField, lockKey, lockTime);
	if (logger.isDebugEnabled()) {
		logger.debug("能够得到锁,方法名为{},参数为{}", joinPoint.getSignature(), String.join("-", Lists.newArrayList(args).stream().map(Object::toString).collect(Collectors.toList())));
	}
	returnObject = joinPoint.proceed(args);
} finally {
	if (cacheUtils.ttl(lockField, lockKey) > 0) {
		cacheUtils.del(lockField, lockKey);
    }
}
复制代码

主要区别在于有两点:

1.以前的建立锁和给锁设置有效时间是分二步进行的，存在风险。万一在建立锁以后宕机了，那么将完全死锁。改良后，将建立锁和给锁设置有效时间合并为一步SetNX，就避免了这个问题。

2.以前的释放锁的过程，只判断了ttl，但无法保证释放锁的时候，本身依然是锁的持有者。若是不加以判断直接释放锁，就会出现误删除其它请求建立的锁的状况。改良后，经过生成一个随机数，而后在释放锁的时候经过lua脚本去执行，先获取锁的值，而后判断释放的锁是不是当初该请求建立的锁，若是是，则释放锁。

if (randomValue.equals(cacheUtils.get(lockField, lockKey))) {
      cacheUtils.del(lockField, lockKey);
}
复制代码

之因此没有采用上述的先get再del的操做，而是采用lua脚本是由于须要保持操做的原子性。假设采用上述的方式，则get和del是分步执行的。那么若是要求a在执行del操做以前，万一由于其余缘由致使没有及时del，此时锁过时自动释放了，这时请求b发现能够建立锁，就建立了锁。而后请求a忽然又恢复正常去释放锁，但此时锁的持有者是请求b，请求a误删了请求b持有的锁。这个问题比较复杂，由于Redis没有get和del合二为一的操做，要解决该问题只能经过lua脚本将这两个操做合二为一，一块儿执行才行。

原理介绍完了，接下来介绍一下如何使用。

lockKey的命名尽可能保持'x='+#x的方式。若是变量是个对象，须要获取到对象中的值，例如是order对象中的orderSn，能够经过order.orderSn方式获取。

@LockAnnotation(lockField = "lock", lockTime = 10, lockKey = "'orderSn='+#orderSn")
public Integer lock(String action, String orderSn) {
    System.out.println(action);
    return 1;
}
复制代码

须要注意的是，常量'orderSn='须要用单引号'，不然会被当作是赋值语法，而#后面的orderSn只要和方法中的变量名orderSn保持一直就能够了

若有更好的建议，欢迎一块儿来沟通。