Redis 分布式锁的java版正确实现

分布式锁一般有三种实现方式：1. 数据库乐观锁；2. 基于Redis的分布式锁；3. 基于ZooKeeper的分布式锁
本文主要介绍了Java代码如何正确实现Redis分布式锁，对于加锁和解锁也分别给出了几个比较经典的错误示例

分布式锁可靠性条件
1.互斥性、在任意时刻，只有一个客户端能持有锁。
2.不会发生死锁、即使有一个客户端在持有锁的期间崩溃而没有主动解锁，也能保证后续其他客户端能加锁。
3.具有容错性、只要大部分的Redis节点正常运行，客户端就可以加锁和解锁。
4.解铃还须系铃人、加锁和解锁必须是同一个客户端，客户端自己不能把别人加的锁给解了。

加锁
正确的加锁方式
private static final String OK = "OK";
 /**
  * 尝试获取分布式锁
  *
  * @param jedis      Redis客户端
  * @param key        锁key
  * @param requestId  值(请求标识)
  * @param expireTime 超期时间
  * @return 是否获取成功
  */
 public static boolean lock(Jedis jedis, String key, String requestId, int expireTime) {
     String result = jedis.set(key, requestId, SET_IF_NOT_EXIST, SET_WITH_EXPIRE_TIME, expireTime);
     if (OK.equals(result)) {
         return true;
     }
     return false;
 }

加锁就一行代码(防并发)
jedis.set(String key, String value, String nxxx, String expx, int time)
该set()方法一共有五个形参：
参数说明
key ：唯一key值，可以使用key来当锁
requestId ：缓存的value 值，用于表示加锁的客户端。解锁时需要判断加锁与解锁是否是相同客户端
nxxx ：常量值NX ，含义是SET IF NOT EXIST，
即当key不存在时，进行set操作；若key已经存在，则不做任何操作
expx ：常量值PX，含义是要给这个key加一个过期的设置，具体时间由第五个参数定
time ：key的过期时间

结果：
执行以上set()方法就只会导致两种结果：
1. 当前没有锁（key不存在），那么就进行加锁操作，并对锁设置个有效期，同时value表示加锁的客户端。
2. 已有锁存在，不做任何操作。
结论：
可靠性条件说明
1.set()方式使用NX参数，可保证如果已有key存在，则函数不会调用成功，也就是只有一个客户端能持有锁，满足互斥性
2.设置过期时间，锁会自动过期，防止死锁发生
3.缓存value值，使用的是客户端请求标识，解锁时可以进行判断符合解铃还须系铃人

错误的加锁方式 1
使用jedis.setnx()和jedis.expire()组合实现加锁，代码如下

private static final Long ONE = 1L;
 /**
  * 分布式锁 错误实现1
  *
  * @param jedis      Redis客户端
  * @param lockKey    锁
  * @param value      值
  * @param expireTime 超期时间
  * @return 是否成功
  * 注：两条Redis命令，不具有原子性，
  * 如果程序在执行完setnx()之后突然崩溃，导致锁没有设置过期时间。那么将会发生死锁
  */
 public static boolean wrongLock01(Jedis jedis, String lockKey, String value, int expireTime) {
     Long result = jedis.setnx(lockKey, value);
     if (ONE == result) {
         // 若在这里程序突然崩溃，则无法设置过期时间，将发生死锁
         jedis.expire(lockKey, expireTime);
         return true;
     }
     return false;
 }

方法说明：
setnx()方法作用就是SET IF NOT EXIST，当key不存在时，进行set操作；若key已经存在，则不做任何操作
expire()方法作用是设置过期时间
错误说明：
由于这是两条Redis命令，不具有原子性，如果程序在执行完setnx()之后突然崩溃，导致锁没有设置过期时间。那么将会发生死锁
注：原先有人这样实现，是因为低版本的jedis并不支持多参数的set()方法。

错误的加锁方式 2
实现步骤：
使用jedis.setnx()命令实现加锁，
其中key是锁，value是锁的过期时间戳。执行过程：

通过setnx()方法尝试加锁，如果当前锁不存在，返回加锁成功。
如果锁已经存在则获取锁的过期时间戳，和当前时间戳比较，
如果锁已经过期，则设置新的过期时间，返回加锁成功
代码如下

private static final Long ONE = 1L;
/**
  * 分布式锁 错误实现2
  *
  * @param jedis      Redis客户端
  * @param lockKey    锁
  * @param expireTime 超期时间
  * @return 是否成功
* 注：风险是各客户端时间必须同步
  */
 public static boolean wrongLock02(Jedis jedis, String lockKey, int expireTime) {
     long expires = System.currentTimeMillis() + expireTime;
     String expiresStr = String.valueOf(expires);
     // 可以成功设置,也就是key不存在
     if (ONE == jedis.setnx(lockKey, expiresStr)) {
         return true;
     }
     //如果锁存在，获取锁的过期时间 防止原来的操作异常，没有运行解锁操作  防止死锁
     String currentValueStr = jedis.get(lockKey);
     if (currentValueStr != null && Long.parseLong(currentValueStr) < System.currentTimeMillis()) {
         // 锁已过期，获取上一个锁的过期时间，并设置现在锁的过期时间
         String oldValueStr = jedis.getSet(lockKey, expiresStr);
         if (!StringUtils.isEmpty(oldValueStr) && oldValueStr.equals(currentValueStr)) {
             //多线程并发的情况，只有一个线程的设置值和当前值相同，它才有权利加锁
             return true;
         }
     }
     // 其他情况，一律返回加锁失败
     return false;
 }
错误说明：
1. 由于是客户端生成过期时间，所以需要分布式下每个客户端的时间必须完全同步。
2. 当锁过期的时候，如果多个客户端同时执行jedis.getSet()方法，
虽然最终只有一个客户端可以加锁，但这个客户端的锁的过期时间可能被其他客户端覆盖。
3. 锁不具备拥有者标识，即任何客户端都可以解锁。不安全

解锁
正确的解锁方式
代码如下

private static final Long ONE = 1L;

  /**
   * 释放分布式锁
   *
   * @param lockKey   锁
   * @param requestId 请求标识
   * @return 是否释放成功
   */
  public static boolean unLock(Jedis jedis, String lockKey, String requestId) {
      String script =
              "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
      Object result =
              jedis.eval(script, Collections.singletonList(lockKey), Collections.singletonList(requestId));
      if (ONE.equals(result)) {
          return true;
      }
      return false;
  }
Redis Eval 命令使用 Lua 解释器执行脚本。
确保上述操作是原子性所以使用Lua语言来实现。
并使参数KEYS[1]赋值为lockKey，ARGV[1]赋值为requestId
eval()方法是将Lua代码交给Redis服务端执行。
效果是什么呢？
首先获取锁对应的value值，检查是否与requestId相等，如果相等则删除锁（解锁）。
下面是官网对eval命令的部分解释：
简单来说，就是在eval命令执行Lua代码的时候，Lua代码将被当成一个命令去执行，并且直到eval命令执行完成，Redis才会执行其他命令。

错误的解锁方式 1
代码如下

 /**
     * 分布式锁解锁 
     * 使用删除方式
     *
     * @param jedis   Redis客户端
     * @param lockKey 锁key
     */
    public static void wrongUnLock01(Jedis jedis, String lockKey) {
        jedis.del(lockKey);
    }    
方法说明：del() 直接删除
错误说明：
未判断锁的拥有者而直接解锁
此方式会导致任何客户端都可以随时进行解锁，即使锁并不是当前客户端的

错误的解锁方式 2
代码如下

/**
     * 分布式锁解锁 错误实现2
     * 使用删除方式
     *
     * @param jedis   Redis客户端
     * @param lockKey 锁key
     *  注：会出现误解锁
     */
    public static void wrongUnLock02(Jedis jedis, String lockKey, String requestId) {
        // 判断加锁与解锁是不是同一个客户端
        if (requestId.equals(jedis.get(lockKey))) {
            // 若在此时，这把锁已经不是这个客户端的，则会误解锁
            jedis.del(lockKey);
        }
    }

方法说明：del() 直接删除
get() 根据key获取值
错误说明：
如果调用jedis.del()方法的时候，这把锁已经不属于当前客户端会解除他人加的锁现象。
例如客户端A加锁，一段时间之后客户端A解锁，
在执行jedis.del()之前，锁过期了，
此时客户端B尝试加锁成功，然后客户端A再执行del()方法，
则将客户端B的锁给解除了。
分成两条命令去执行难免出现并发的现象
————————————————
版权声明：本文为CSDN博主「码农猿」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_38011415/article/details/83002487