redis 分布式锁

Map<String, Object> annotationArgs = this.getAnnotationArgs(pjp);
String lockPrefix = (String) annotationArgs.get(LOCK_NAME);
Assert.notNull(lockPrefix, "分布式,锁名不能为空");

int retryTimes = (int) annotationArgs.get(RETRY_TIMES);
long retryWait = (long) annotationArgs.get(RETRY_WAIT);
int keepMinTime = (int) annotationArgs.get(KEEP_MIN_TIME);
String keyName = parseKey(lockPrefix, method, pjp.getArgs());

// 获取redis锁,防止死锁
boolean keyLock = redisCacheSvc.keyLock(keyName, keepMinTime);
if(keyLock){
//执行主程序
return pjp.proceed();
}else{
if(retryTimes <= 0){
log.info(String.format("{%s}已经被锁, 不重试", keyName));
throw new RuntimeException(String.format("{%s}已经被锁, 不重试", keyName));
}

int failCount = 1;
while (failCount <= retryTimes) {
// 等待指定时间ms
try {
Thread.sleep(retryWait);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (redisCacheSvc.keyLock(keyName, keepMinTime)) {
// 执行主逻辑
return pjp.proceed();
} else {
log.info(String.format("{%s}已经被锁, 正在重试[ %s/%s ],重试间隔{%s}毫秒", keyName, failCount, retryTimes, retryWait));
failCount++;
}
}

throw new RuntimeException("系统繁忙, 请稍等再试");
}

}
/**

• 获取锁参数
• @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_NAME, redisLock.lockName());
  result.put(RETRY_TIMES, redisLock.retryTimes());
  result.put(RETRY_WAIT, redisLock.retryWait());
  result.put(KEEP_MIN_TIME, redisLock.keeyMinTime());
  return result;
  }
  }
  return null;
  }
  private Method returnMethod(ProceedingJoinPoint pjp)
  throws NoSuchMethodException {
  Signature signature = pjp.getSignature();
  Class<? extends Object> cls = pjp.getTarget().getClass();
  MethodSignature methodSignature = (MethodSignature) signature;
  Method targetMethod = methodSignature.getMethod();
  Method method = cls.getDeclaredMethod(signature.getName(),
  targetMethod.getParameterTypes());
  return method;
  }
  /**
• 获取缓存的key key 定义在注解上，支持SPEL表达式
• @param pjp
• @return
  */
  private String parseKey(String key, Method method, Object[] args) {
  // 获取被拦截方法参数名列表(使用Spring支持类库)
  LocalVariableTableParameterNameDiscoverer u = new LocalVariableTableParameterNameDiscoverer();
  String[] paraNameArr = u.getParameterNames(method);
  // 使用SPEL进行key的解析
  ExpressionParser parser = new SpelExpressionParser();
  // SPEL上下文
  StandardEvaluationContext context = new StandardEvaluationContext();
  // 把方法参数放入SPEL上下文中
  for (int i = 0; i < paraNameArr.length; i++) {
  context.setVariable(paraNameArr[i], args[i]);
  }
  return parser.parseExpression(key).getValue(context, String.class);
  }
  }
  搭建完成后直接在需要锁住的接口上注解

@RedisLock(lockName="‘lock_‘+#tbbId",retryTimes=5)
模拟高并发测试

for (int i = 0; i < 2; i++) {
threadPoolTaskExecutor.execute(new StartTaskThread(redisCacheSvc, i, threadPoolTaskExecutor));
}
redis 分布式锁
效果就是这样了

觉得还不错的朋友 后台回复“Java”领取资料 一起交流