Redisson分布式锁使用详解

引言

日常开发中，难免遇到一些并发的场景，为了保证接口执行的一致性，通常采用加锁的方式，因为服务是分布式部署模式，本地锁Reentrantlock和Synchnorized这些就先放到一边了，Redis的setnx锁存在无法抱保证原子性的问题就暂时搁且到一边，直接上大招Redisson也是我最近开发项目中基本都在用的缓存，并且也都是用它的分布式锁机制。

为什么要使用分布式锁

在分布式系统中，常常需要协调他们的动作。如果不同的系统或是同一个系统的不同主机之间共享了一个或一组资源，那么访问这些资源的时候，往往需要互斥来防止彼此干扰来保证一致性，这个时候，便需要使用到分布式锁。

目前几乎很多大型网站及应用都是分布式部署的，如何保证分布式场景中的数据一致性问题一直是一个比较重要的话题。在某些场景下，为了保证数据的完整性和一致性，我们需要保证一个方法在同一时间内只能被同一个线程执行，这就需要使用分布式锁。

分布式锁需满足四个条件

为了确保分布式锁可用，我们至少要确保锁的实现同时满足以下四个条件：

1. 互斥性。在任意时刻，只有一个客户端能持有锁。

2. 不会发生死锁。即使有一个客户端在持有锁的期间崩溃而没有主动解锁，也能保证后续其他客户端能加锁。

3. 解铃还须系铃人。加锁和解锁必须是同一个客户端，客户端自己不能把别人加的锁给解了，即不能误解锁。

4. 具有容错性。只要大多数Redis节点正常运行，客户端就能够获取和释放锁。

Redisson 分布式锁实现原理图

Redisson分布式锁常规使用 

关于Redisson的一些基本概念，本章就不做太详细的说明了，有兴趣的小伙伴可以自己去了解下，主要说下加锁的常规使用，Redisson分布式锁是基于Redis的Rlock锁，实现了JavaJUC包下的Lock接口。

Lock

public void getLock(){     //获取锁     RLock lock = redisson.getLock("Lxlxxx_Lock");     try {         // 2.加锁         lock.lock();      } catch (InterruptedException e) {         e.getStackTrace();     } finally {         // 3.解锁         lock.unlock();         System.out.println("Finally，释放锁成功");     }

getLock获取锁，lock.lock进行加锁，会出现的问题就是lock拿不到锁一直等待，会进入阻塞状态，显然这样是不好的。

TryLock 

返回boolean类型，和Reentrantlock的tryLock是一个意思，尝试获取锁，获取到就返回true，获取失败就返回false，不会使获不到锁的线程一直处于等待状态，返回false可以继续执行下面的业务逻辑，当然Ression锁内部也涉及到watchDog看门狗机制，主要作用就是给快过期的锁进行续期，主要用途就是使拿到锁的有限时间让业务执行完，再进行锁释放。

RLock lock = redisson.getLock(name); try {      if (lock.tryLock(2, 10, TimeUnit.SECONDS)) {         //执行业务逻辑     } else {         System.out.println("已存在");     } } catch (InterruptedException e) {     e.printStackTrace(); }finally { //判断当前线程持有的锁是不是处于锁定状态，锁定状态再进行释放     if (this.redissonLock.isHeldByCurrentThread(lockName)) {         this.redissonLock.unlock(lockName);     } }

自定义注解实现锁机制

通常我们都会将redisson实例注入到方法类里面，然后调用加锁方法进行加锁，如果其他业务方法也需要加锁执行，将会产生很多重复代码，由此采用AOP切面的方式，只需要通过注解的方式就能将方法进行加锁处理。

自定义注解

@Documented @Inherited @Retention(RetentionPolicy.RUNTIME) @Target({ElementType.METHOD}) public @interface DistributedLock {     String key() default "";      int leaseTime() default 10;      boolean autoRelease() default true;      String errorDesc() default "系统正常处理，请稍后提交";      int waitTime() default 1; }

切面类实现 

@Aspect @Component public class DistributedLockHandler {     private static final Logger log = LoggerFactory.getLogger(DistributedLockHandler.class);     @Autowired     RedissonLock redissonLock;      public DistributedLockHandler() {     }      @Around("@annotation(distributedLock)")     public Object around(ProceedingJoinPoint joinPoint, DistributedLock distributedLock) throws Throwable {         String lockName = this.getRedisKey(joinPoint, distributedLock);         int leaseTime = distributedLock.leaseTime();         String errorDesc = distributedLock.errorDesc();         int waitTime = distributedLock.waitTime();          Object var8;         try {             boolean lock = this.redissonLock.tryLock(lockName, (long)leaseTime, (long)waitTime);             if (!lock) {                 throw new RuntimeException(errorDesc);             }              var8 = joinPoint.proceed();         } catch (Throwable var12) {             log.error("执行业务方法异常", var12);             throw var12;         } finally {             if (this.redissonLock.isHeldByCurrentThread(lockName)) {                 this.redissonLock.unlock(lockName);             }          }          return var8;     }       /**      *  获取加锁的key      * @param joinPoint      * @param distributedLock      * @return      */     private String getRedisKey(ProceedingJoinPoint joinPoint, DistributedLock distributedLock) {         String key = distributedLock.key();         Object[] parameterValues = joinPoint.getArgs();         MethodSignature signature = (MethodSignature)joinPoint.getSignature();         Method method = signature.getMethod();         DefaultParameterNameDiscoverer nameDiscoverer = new DefaultParameterNameDiscoverer();         String[] parameterNames = nameDiscoverer.getParameterNames(method);         if (StringUtils.isEmpty(key)) {             if (parameterNames != null && parameterNames.length > 0) {                 StringBuffer sb = new StringBuffer();                 int i = 0;                  for(int len = parameterNames.length; i < len; ++i) {                     sb.append(parameterNames[i]).append(" = ").append(parameterValues[i]);                 }                  key = sb.toString();             } else {                 key = "redissionLock";             }              return key;         } else {             SpelExpressionParser parser = new SpelExpressionParser();             Expression expression = parser.parseExpression(key);             if (parameterNames != null && parameterNames.length != 0) {                 EvaluationContext evaluationContext = new StandardEvaluationContext();                  for(int i = 0; i < parameterNames.length; ++i) {                     evaluationContext.setVariable(parameterNames[i], parameterValues[i]);                 }                  try {                     Object expressionValue = expression.getValue(evaluationContext);                     return expressionValue != null && !"".equals(expressionValue.toString()) ? expressionValue.toString() : key;                 } catch (Exception var13) {                     return key;                 }             } else {                 return key;             }         }     } }