Redis分布式锁

Redis使用方式

前言

分布式锁一般有三种实现方式：1. 数据库乐观锁；2. 基于Redis的分布式锁；3. 基于ZooKeeper的分布式锁。本篇博客将介绍第二种方式，基于Redis实现分布式锁。虽然网上已经有各种介绍Redis分布式锁实现的博客，然而他们的实现却有着各种各样的问题，为了避免误人子弟，本篇博客将详细介绍如何正确地实现Redis分布式锁。

可靠性

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

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

代码实现

组件依赖
首先我们要通过Maven引入Jedis开源组件，在pom.xml文件加入下面的代码：

redis.clients jedis 2.9.0

加锁代码

正确姿势
Talk is cheap, show me the code。先展示代码，再带大家慢慢解释为什么这样实现：
public class RedisTool {

private static final String LOCK_SUCCESS = "OK";
private static final String SET_IF_NOT_EXIST = "NX";
private static final String SET_WITH_EXPIRE_TIME = "PX";

/**
 * 尝试获取分布式锁
 * @param jedis Redis客户端
 * @param lockKey 锁
 * @param requestId 请求标识
 * @param expireTime 超期时间
 * @return 是否获取成功
 */
public static boolean tryGetDistributedLock(Jedis jedis, String lockKey, String requestId, int expireTime) {

    String result = jedis.set(lockKey, requestId, SET_IF_NOT_EXIST, SET_WITH_EXPIRE_TIME, expireTime);

    if (LOCK_SUCCESS.equals(result)) {
        return true;
    }
    return false;
}

}

可以看到，我们加锁就一行代码：jedis.set(String key, String value, String nxxx, String expx, int time)，这个set()方法一共有五个形参：

第一个为key，我们使用key来当锁，因为key是唯一的。
第二个为value，我们传的是requestId，很多童鞋可能不明白，有key作为锁不就够了吗，为什么还要用到value？原因就是我们在上面讲到可靠性时，分布式锁要满足第四个条件解铃还须系铃人，通过给value赋值为requestId，我们就知道这把锁是哪个请求加的了，在解锁的时候就可以有依据。requestId可以使用UUID.randomUUID().toString()方法生成。
第三个为nxxx，这个参数我们填的是NX，意思是SET IF NOT EXIST，即当key不存在时，我们进行set操作；若key已经存在，则不做任何操作；
第四个为expx，这个参数我们传的是PX，意思是我们要给这个key加一个过期的设置，具体时间由第五个参数决定。
第五个为time，与第四个参数相呼应，代表key的过期时间。

总的来说，执行上面的set()方法就只会导致两种结果：1. 当前没有锁（key不存在），那么就进行加锁操作，并对锁设置个有效期，同时value表示加锁的客户端。2. 已有锁存在，不做任何操作。
心细的童鞋就会发现了，我们的加锁代码满足我们可靠性里描述的三个条件。首先，set()加入了NX参数，可以保证如果已有key存在，则函数不会调用成功，也就是只有一个客户端能持有锁，满足互斥性。其次，由于我们对锁设置了过期时间，即使锁的持有者后续发生崩溃而没有解锁，锁也会因为到了过期时间而自动解锁（即key被删除），不会发生死锁。最后，因为我们将value赋值为requestId，代表加锁的客户端请求标识，那么在客户端在解锁的时候就可以进行校验是否是同一个客户端。由于我们只考虑Redis单机部署的场景，所以容错性我们暂不考虑。
错误示例1
比较常见的错误示例就是使用jedis.setnx()和jedis.expire()组合实现加锁，代码如下：
public static void wrongGetLock1(Jedis jedis, String lockKey, String requestId, int expireTime) {

Long result = jedis.setnx(lockKey, requestId);
if (result == 1) {
    // 若在这里程序突然崩溃，则无法设置过期时间，将发生死锁
    jedis.expire(lockKey, expireTime);
}

}
setnx()方法作用就是SET IF NOT EXIST，expire()方法就是给锁加一个过期时间。乍一看好像和前面的set()方法结果一样，然而由于这是两条Redis命令，不具有原子性，如果程序在执行完setnx()之后突然崩溃，导致锁没有设置过期时间。那么将会发生死锁。网上之所以有人这样实现，是因为低版本的jedis并不支持多参数的set()方法。
错误示例2
public static boolean wrongGetLock2(Jedis jedis, String lockKey, int expireTime) {

long expires = System.currentTimeMillis() + expireTime;
String expiresStr = String.valueOf(expires);

// 如果当前锁不存在，返回加锁成功
if (jedis.setnx(lockKey, expiresStr) == 1) {
    return true;
}
// 如果锁存在，获取锁的过期时间
String currentValueStr = jedis.get(lockKey);
if (currentValueStr != null && Long.parseLong(currentValueStr) < System.currentTimeMillis()) {
    // 锁已过期，获取上一个锁的过期时间，并设置现在锁的过期时间
    String oldValueStr = jedis.getSet(lockKey, expiresStr);
    if (oldValueStr != null && oldValueStr.equals(currentValueStr)) {
        // 考虑多线程并发的情况，只有一个线程的设置值和当前值相同，它才有权利加锁
        return true;
    }
}
    
// 其他情况，一律返回加锁失败
return false;

}
这一种错误示例就比较难以发现问题，而且实现也比较复杂。实现思路：使用jedis.setnx()命令实现加锁，其中key是锁，value是锁的过期时间。执行过程：1. 通过setnx()方法尝试加锁，如果当前锁不存在，返回加锁成功。2. 如果锁已经存在则获取锁的过期时间，和当前时间比较，如果锁已经过期，则设置新的过期时间，返回加锁成功。代码如下：

那么这段代码问题在哪里？1. 由于是客户端自己生成过期时间，所以需要强制要求分布式下每个客户端的时间必须同步。 2. 当锁过期的时候，如果多个客户端同时执行jedis.getSet()方法，那么虽然最终只有一个客户端可以加锁，但是这个客户端的锁的过期时间可能被其他客户端覆盖。3. 锁不具备拥有者标识，即任何客户端都可以解锁。

解锁代码

正确姿势
还是先展示代码，再带大家慢慢解释为什么这样实现：
public class RedisTool {
private static final Long RELEASE_SUCCESS = 1L;
/**
* 释放分布式锁
* @param jedis Redis客户端
* @param lockKey 锁
* @param requestId 请求标识
* @return 是否释放成功
*/
public static boolean releaseDistributedLock(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 (RELEASE_SUCCESS.equals(result)) {
        return true;
    }
    return false;
}

}
可以看到，我们解锁只需要两行代码就搞定了！第一行代码，我们写了一个简单的Lua脚本代码，上一次见到这个编程语言还是在《黑客与画家》里，没想到这次居然用上了。第二行代码，我们将Lua代码传到jedis.eval()方法里，并使参数KEYS[1]赋值为lockKey，ARGV[1]赋值为requestId。eval()方法是将Lua代码交给Redis服务端执行。
那么这段Lua代码的功能是什么呢？其实很简单，首先获取锁对应的value值，检查是否与requestId相等，如果相等则删除锁（解锁）。那么为什么要使用Lua语言来实现呢？因为要确保上述操作是原子性的。关于非原子性会带来什么问题，可以阅读【解锁代码-错误示例2】 。那么为什么执行eval()方法可以确保原子性，源于Redis的特性，下面是官网对eval命令的部分解释：
简单来说，就是在eval命令执行Lua代码的时候，Lua代码将被当成一个命令去执行，并且直到eval命令执行完成，Redis才会执行其他命令。
错误示例1
最常见的解锁代码就是直接使用jedis.del()方法删除锁，这种不先判断锁的拥有者而直接解锁的方式，会导致任何客户端都可以随时进行解锁，即使这把锁不是它的。

public static void wrongReleaseLock1(Jedis jedis, String lockKey) {
jedis.del(lockKey);
}
错误示例2
这种解锁代码乍一看也是没问题，甚至我之前也差点这样实现，与正确姿势差不多，唯一区别的是分成两条命令去执行，代码如下：
public static void wrongReleaseLock2(Jedis jedis, String lockKey, String requestId) {

// 判断加锁与解锁是不是同一个客户端
if (requestId.equals(jedis.get(lockKey))) {
    // 若在此时，这把锁突然不是这个客户端的，则会误解锁
    jedis.del(lockKey);
}

}

如代码注释，问题在于如果调用jedis.del()方法的时候，这把锁已经不属于当前客户端的时候会解除他人加的锁。那么是否真的有这种场景？答案是肯定的，比如客户端A加锁，一段时间之后客户端A解锁，在执行jedis.del()之前，锁突然过期了，此时客户端B尝试加锁成功，然后客户端A再执行del()方法，则将客户端B的锁给解除了。

总结

本文主要介绍了如何使用Java代码正确实现Redis分布式锁，对于加锁和解锁也分别给出了两个比较经典的错误示例。其实想要通过Redis实现分布式锁并不难，只要保证能满足可靠性里的四个条件。互联网虽然给我们带来了方便，只要有问题就可以google，然而网上的答案一定是对的吗？其实不然，所以我们更应该时刻保持着质疑精神，多想多验证。

锁的几种实现方式，Redisson的配置和使用

最近在开发中涉及到了多个客户端的对redis的某个key同时进行增删的问题。这里就会涉及一个问题：

锁先举例在分布式中不加锁会出现问题：

redis中存放了某个用户的账户余额 ，例如100 （用户id：余额）　　A端需要对用户扣费-1，需要两步：　　　　A1.将该用户的目前余额取出来(100)　　　　A2.将余额扣除一部分(99)后再插入到redis中　　B端需要对用户充值+10，需要两步：　　　　B1.将该用户的目前余额取出来(99)　　　　B2.将余额添加充值额度(109)后再插入到redis中　　我们的期望执行顺序是A1、A2、B1、B2 结果就会是109　　但是如果不加锁，就会出现A1、B1、A2、B2(110)或者其他各种随机情况，这样就会造成数据错误。

Redis加锁的几种实现方式

方式一，自己造轮子

之前参考的很多博客，关于redis加锁都是先setNX()获取锁，然后再setExpire()设置锁的有效时间。然而这样的话获取锁的操作就不是原子性的了，如果setNX后系统宕机，就会造成锁死，系统阻塞。根据官方的推荐（https://redis.io/topics/distlock），最好使用set命令：SET key value [EX seconds] [PX milliseconds] [NX|XX] EX PX设置有效时间 NX属性的作用就是如果key存在就返回失败，否则插入数据。
需要注意的是：在Redis 2.6.12之前，set只能返回OK,所以无法判断操作是否成功，所以也就不适用。如果使用的是spring-boot-starter-data-redis依赖，那么在2.x版本之前的接口也不支持上述的set操作

java代码：//获取锁

    //锁的键值需要具有标志性。
    //例如，现在有两个系统需要对key=user_id,value=user_balance进行操作，这时就可以设计这个键的锁为user_id+"_key"
    String user_id="1";
    String key=user_id+"_key";
    //值设置为一个随机数（下面讲原因）
    String random_value=UUID.randomUUID().toString();
    redisTemplate.execute((RedisCallback<Boolean>) (RedisConnection connection)->{
        //只有2.0以上的版本才支持set返回插入结果Boolean
        //此命令的意思是只有key不存在，才插入值，并且设置有效时间为10s
        connection.set(key.getBytes(), random_value.getBytes(), Expiration.seconds(10), SetOption.SET_IF_ABSENT);
        //本示例由于依赖版本低于2.0,所以无法接受set设置结果
        Boolean result=true;
        return result;
    });
    
    //进行更新操作...

释放锁

    //为什么释放之前要比较一下？
    //这是为了防止删除掉别人的锁，例如此场景中：如果我们的中间操作超过了10s那么锁会自动释放，这时别人会再获取锁。
    //如果我们执行完中间就直接删除锁的话，就会把别人的锁删除
    if(redisTemplate.opsForValue().get(key)==random_value) {
        redisTemplate.delete(key);
    }可以发现，如果自己来实现的话，受限很多。并且这还是最基本的操作，包括出错重试等功能都没有。所以我们要学习redis推荐的reids工具redisson　　

方式二：集成redisson

（https://github.com/redisson/redisson/wiki/2.-%E9%85%8D%E7%BD%AE%E6%96%B9%E6%B3%95）　　一.添加依赖
org.redisson
redisson
3.6.1

二.在resources文件夹添加配置文件redisson.ymlsingleServerConfig:

#连接空闲超时，单位：毫秒
idleConnectionTimeout: 10000
pingTimeout: 1000
#连接超时，单位：毫秒
connectTimeout: 10000
#命令等待超时，单位：毫秒
timeout: 3000
#命令失败重试次数
retryAttempts: 3
#命令重试发送时间间隔，单位：毫秒
retryInterval: 1500
#重新连接时间间隔，单位：毫秒
reconnectionTimeout: 3000
#执行失败最大次数
failedAttempts: 3
#单个连接最大订阅数量
subscriptionsPerConnection: 5
#客户端名称
clientName: null
#地址
address: “redis://192.168.1.16:6379”
#数据库编号
database: 0
#密码
password: xiaokong
#发布和订阅连接的最小空闲连接数
subscriptionConnectionMinimumIdleSize: 1
#发布和订阅连接池大小
subscriptionConnectionPoolSize: 50
#最小空闲连接数
connectionMinimumIdleSize: 32
#连接池大小
connectionPoolSize: 64
#是否启用DNS监测
dnsMonitoring: false
#DNS监测时间间隔，单位：毫秒
dnsMonitoringInterval: 5000
threads: 0
nettyThreads: 0
codec: !<org.redisson.codec.JsonJacksonCodec> {}
transportMode : “NIO”

三.在Application中设置RedissonClientimport org.mybatis.spring.annotation.MapperScan;

import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.context.annotation.Bean;
import org.springframework.core.io.ClassPathResource;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@SpringBootApplication
@EnableTransactionManagement
@MapperScan(“com.xxx.mapper”)
public class Application {
public static void main(String [] args) {
SpringApplication.run(Application.class, args);
}
@Bean(destroyMethod=“shutdown”)
public RedissonClient redisson() throws IOException {
RedissonClient redisson = Redisson.create(
Config.fromYAML(new ClassPathResource(“redisson.yml”).getInputStream()));
return redisson;
}
}

四.在代码中使用

@Autowired
private RedissonClient redisson;
@Test 
public void redisson() {
    String user_id="1";
    String key=user_id+"_key";
    //获取锁
    RLock lock = redisson.getLock(key);
    lock.lock();
        //执行具体逻辑...
    
    RBucket<Object> bucket = redisson.getBucket("a");
    bucket.set("bb");
    
    lock.unlock();
}
***需要注意*** redisson的使用和redisTemplate有比较大的区别，这里简单介绍一下几个特性：（刚用时迷了很久，希望大家能少走些弯路）1.在redisson中不需要set指令，举个例子：RBucket<Object> bucket = redisson.getBucket("a");

bucket.set(“bb”);在这两条语句中，我们只获取了key="a"的bucket类型对象(里面可以装一个任意对象)。然后修改bucket里面一个值，其实这时[“a”,“bb”]已经被存入redis了2.所有的值都是结构体和上例的RBucket结构体一样，redisson提供了十几种结构体（https://github.com/redisson/redisson/wiki/7.-%E5%88%86%E5%B8%83%E5%BC%8F%E9%9B%86%E5%90%88）供我们使用，当取值时，redisson也会自动将值转换成对应的结构体。所以如果使用redisson取redisTemplate放入的值，就要小心报错

方式三.

基于redlock的算法讨论这种我还没有具体实现过，为什么会出现这种算法，主要是应对redis服务器宕机的问题。当redis宕机时，即使有主从，但是依然会有一个同步间隔。这样就会造成数据流失。当然，更为严重的是，在分布式情况下，丢失的是锁，我们知道一般用锁的数据都是比较重要的。一个场景：A在向主机1请求到锁成功后，主机1宕机了。现在从机1a变成了主机。但是数据没有同步，从机1a是没有A的锁的。那么B又可以获得一个锁。这样就会造成数据错误。redlock主要思想就是做数据冗余。建立5台独立的集群，当我们发送一个数据的时候，要保证3台（n/2+1）以上的机器接受成功才算成功，否则重试或报错。当然具体是很复杂，想研究的可以看看（https://redis.io/topics/distlock）

方式四.

使用zookeeper+redis来管理锁就像之前讨论的，方式2只能保证客户端的正确，却无法保证服务端的宕机数据丢失。方式三的数据完整性很高，但是管理起来很复杂。这时就有了一个折中的做法：将锁存放在zookeeper中，由于zookeeper与redis的场景不同，所以zookeeper的算法对数据的完整性要求很高。在分布式的zookeeper中，数据是很难丢失的。这样，我们就可以把锁放到zookeeper中，来保证锁的完整性。

总结

 一般项目用方式二就可以啦