基於AOP和Redis實現的簡易版分散式鎖

逍遙jc發表於2018-12-09

原文首發於簡書,本文將《基於AOP和Redis實現的簡易版分散式鎖》《基於AOP和Redis實現的簡易版分散式鎖(二)》兩篇文章進行了整合,修改了部分內容。

平時在專案中經常會遇到併發問題,理論上有些方法只應該被呼叫一次,但由於併發而被重複呼叫,導致出現系統問題。而在我們的專案中,最容易發生這種情況的是,推送訊息的服務。無論是簡訊還是app推送,或者是公眾號的推送,因為併發問題而導致的重複推送,肯定是不被允許的。

所以我準備通過分散式鎖去解決這個問題。

分散式鎖一般解決如下兩類問題:

1、效率性問題,比如重複發簡訊,重複生成同樣的訂單等。

2、正確性問題,比如在某一個請求扣款的同時不允許其他請求同時去扣款。

當然,題目中寫了簡易版是因為,這次的分散式鎖只准備解決效率性的問題,而不解決正確性的問題。

之所以基於Redis,是因為Redis作為一款基本上網際網路公司都會必備的快取資料庫,簡單好用,入門門檻較低。

而基於AOP實現,是因為用註解方式侵入性更低,基本上不需要修改原生程式碼,只需要加註解就行。

如下是簡易版的分散式鎖的實現方式:

首先我們需要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(1000, 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保持一直就可以了

如有更好的建議,歡迎一起來溝通。

相關文章