原文首发于简书,本文将《基于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保持一直就可以了
如有更好的建议,欢迎一起来沟通。