基于redis实现分布式锁的原理与方法

前言

系统的不断扩大，分布式锁是最基本的保障。与单机的多线程不一样的是，分布式跨多个机器。线程的共享变量无法跨机器。

为了保证一个在高并发存场景下只能被同一个线程操作，java并发处理提供reentrantlock或synchronized进行互斥控制。但是这仅仅对单机环境有效。我们实现分布式锁大概通过三种方式。

• redis实现分布式锁
• 数据库实现分布式锁
• zk实现分布式锁
  

今天我们介绍通过redis实现分布式锁。实际上这三种和java对比看属于一类。都是属于程序外部锁。

原理剖析

• 上述三种分布式锁都是通过各自为依据对各个请求进行上锁，解锁从而控制放行还是拒绝。redis锁是基于其提供的setnx命令。
• setnx当且仅当key不存在。若给定key已经存在，则setnx不做任何动作。setnx是一个原子性操作。
• 和数据库分布式相比，因为redis内存轻量。所以redis分布式锁性能更好
  

实现

原理很简单。结合springboot项目我们实现一套通过注解形式对接口进行库存上锁案例进行理解

编写注解

我们编写注解。方便我们在接口上添加注解提供拦截信息

/**
 * @author 张新华
 * @version v1.0
 * @package com.ay.framework.order.redis.product
 * @date 2020年03月26日, 0026 10:29
 * @copyright © 2020 安元科技有限公司
 */
@target(elementtype.method)
@retention(retentionpolicy.runtime)
@documented
@inherited
public @interface stocklock {

  /**
   * @author zxhtom
   * @description 锁key的前缀
   * @date 15:25 2020年03月25日, 0025
   * @param []
   * @return java.lang.string
   */
  string prefix() default "";
  /**
   * @author zxhtom
   * @description key的分隔符
   * @date 15:27 2020年03月25日, 0025
   * @param []
   * @return java.lang.string
   */
  string delimiter() default ":";
}

/**
 * @author 张新华
 * @version v1.0
 * @package com.ay.framework.order.redis.product
 * @date 2020年03月26日, 0026 11:09
 * @copyright © 2020 安元科技有限公司
 */
@target({elementtype.parameter , elementtype.method , elementtype.field})
@retention(retentionpolicy.runtime)
@documented
@inherited
public @interface stockparam {
  /**
  * @author zxhtom
  * @description 组成key
  * @date 11:11 2020年03月26日, 0026
  * @param []
  * @return java.lang.string[]
  */
  string[] names() default {""};
}

拦截器拦截

redis分布式锁实现的关键就是拦截器的编写。上面的注解只是为了实现拦截的一个辅助。

@around("execution(public * *(..)) && @annotation(com.ay.framework.order.redis.product.stocklock)")

通过springboot的around进行针对stocklock注解的拦截。通过拦截我们可以获取到拦截的方法、参数、及需要的锁的参数。

我们获取到需要锁的名称这里叫做【a】之后通过redis的原子性操作对该key进行递减操作。

为了方便我们在削减库存的时候可以对库存进行更新操作。我们在递减库存前还需要借助于另一把锁。 这一把锁我们叫做【a_key】

换句话说我们接口想访问就必须获取【a】锁，拿到【a】锁需要减少库存。减少库存之前需要获取【a_key】锁。

拿到锁之后处理完逻辑之后我们需要释放对应锁。

redisatomiclong entityidcounter = new redisatomiclong(lockkey, redistemplate.getconnectionfactory());
  if (redistemplate.haskey(coreconstants.updateproductredislockkey + lockkey)) {
    //表示lockkey的库存信息有变动。此时无法进行交易
    throw new businessexception("库存变动。暂无法交易");
  }
  long increment = entityidcounter.decrementandget();
  if (increment >= 0) {
    try {
      object proceed = pjp.proceed();
    } catch (throwable throwable) {
      //所占资源需要释放回资源池
      while (!redislock.trygetlock(coreconstants.updateproductredislockkey + lockkey, "")) {

      }
      //表示lockkey的库存信息有变动。此时无法进行交易
      long l = entityidcounter.incrementandget();
      if (l < 1) {
        redistemplate.opsforvalue().set(lockkey,1);
      }
      redislock.unlock(coreconstants.updateproductredislockkey + lockkey);
      throwable.printstacktrace();
    }
  } else {
    redistemplate.opsforvalue().set(lockkey,0);
    throw new businessexception("库存不足！无法操作");
  }

因为我们上锁就需要释放锁。但是程序在中途处理业务是发生异常导致没有走到释放锁的步骤。这个时候就导致我们的分布式锁一直被锁。俗称【死锁】。为了避免这种场景的发生。我们常常在上锁的时候给一个有效期。有效期已过自动释放锁。这个特性恰好和redis的过期策略不摩尔和。

上述提及工具

redislock

public boolean trygetlock(string key , string value) {
  return trygetlock(key, value, -1, timeunit.days);
}
public boolean trygetlock(string key , string value, integer expire) {
  return trygetlock(key, value, expire, timeunit.seconds);
}
public boolean trygetlock(string key , string value, integer expire , timeunit timeunit) {
  valueoperations operations = redistemplate.opsforvalue();
  if (operations.setifabsent(key, value)) {
    //说明 redis没有该key , 换言之 加锁成功 设置过期时间防止死锁
    if (expire > 0) {
      redistemplate.expire(key, expire, timeunit);
    }
    return true;
  }
  return false;
}

public boolean unlock(string key) {
  return redistemplate.delete(key);
}

stockkeygenerator

@component()
@primary
public class stockkeygenerator implements cachekeygenerator {
  @override
  public string getlockkey(proceedingjoinpoint pjp) {
    //获取方法签名
    methodsignature signature = (methodsignature) pjp.getsignature();
    method method = signature.getmethod();
    //获取方法cachelock注解
    stocklock stocklock = method.getannotation(stocklock.class);
    //获取方法参数
    object[] args = pjp.getargs();
    parameter[] parameters = method.getparameters();
    stringbuilder builder = new stringbuilder();
    for (int i = 0; i < parameters.length; i++) {
      stockparam stockparam = parameters[i].getannotation(stockparam.class);
      object arg = args[i];
      if (arg instanceof map) {
        map<string, object> temargmap = (map<string, object>) arg;
        string[] names = stockparam.names();
        for (string name : names) {
          if (builder.length() > 0) {
            builder.append(stocklock.delimiter());
          }
          builder.append(temargmap.get(name));
        }
      }

    }
    return builder.tostring();
  }
}

问题分析

上面分析了一个死锁的场景，理论上出了死锁我们redis分布锁很好的解决了分布式问题。但是还是会出现问题。下面列举写小编遇到的问题。

业务处理时间>上锁过期时间

a线程获取到锁，开始进行业务处理需要8s，

在8s内，锁的有效期是5s，在锁过期后也就是第6s ， b线程进入开始获取锁这个时候b是可以获取到新锁的。这个时候就是有问题的。

假设b线程业务处理只需要3s ， 但是因为a线程释放了锁，所以在第8s的时候虽然b线程没有释放锁，b的锁也没有过期但是这时候也没有了锁。从而导致c线程也可以进入

总结

到此这篇基于redis实现分布式锁的原理与方法的文章就介绍到这了,更多相关redis分布式锁内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！