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保持一直就能夠了

若有更好的建議，歡迎一塊兒來溝通。