redis分布式锁

什么是分布式锁

分布式锁用在分布式系统中，分布式系统即单个系统多个部署，通过负载均衡，实现系统快速稳定响应。在我们对同一条数据进行修改的时候，极有可能造成脏数据。分布式锁的作用就是保证数据的接近原子性操作，简要说就是保证多个系统中的某一方法同一时间只能运行一个。

如何使用redis分布式锁

老版本：
jedis.setnx(key,value);

只在键 key 不存在的情况下， 将键 key 的值设置为 value 。

若键 key 已经存在， 则 SETNX 命令不做任何动作。

SETNX 是『SET if Not eXists』(如果不存在，则 SET)的简写。

jedis.expire(key,expireTimes);

设置过期时间，单位秒

新版本：
SET key value [EX seconds] [PX milliseconds] [NX|XX]

从2.6.12版本开始，redis为SET命令增加了一系列选项:

EX seconds – Set the specified expire time, in seconds.
PX milliseconds – Set the specified expire time, in milliseconds.
NX – Only set the key if it does not already exist.
XX – Only set the key if it already exist.

EX seconds – 设置键key的过期时间，单位时秒
PX milliseconds – 设置键key的过期时间，单位时毫秒
NX – 只有键key不存在的时候才会设置key的值
XX – 只有键key存在的时候才会设置key的值
例子：jedis.set(key,value,‘EX’,‘NX’,30);

比较：
老版本为了防止因为没有设置过期时间同事系统出错导致无法解锁，从而造成死锁，所以经常两个命令一起使用，但是由于两个命令并不是原子性操作，所以依旧存在风险；相对而言，新版本的命令是一个原子性操作，比较安全。

操作示例：

加锁：

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值，使用的是客户端请求标识，解锁时可以进行判断符合解铃还须系铃人

错误的加锁方式一：

使用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()方法。

错误的加锁方式二：

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

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

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才会执行其他命令。

错误的解锁方式一：

/**
     * 分布式锁解锁 
     * 使用删除方式
     *
     * @param jedis   Redis客户端
     * @param lockKey 锁key
     */
    public static void wrongUnLock01(Jedis jedis, String lockKey) {
        jedis.del(lockKey);
    }	

方法说明：del() 直接删除
错误说明：
未判断锁的拥有者而直接解锁
此方式会导致任何客户端都可以随时进行解锁，即使锁并不是当前客户端的

错误的解锁方式二：

/**
     * 分布式锁解锁 错误实现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的锁给解除了。
分成两条命令去执行难免出现并发的现象