「这是我参与2022首次更文挑战的第26天，活动详情查看：2022首次更文挑战」。

问题：你知道 redis 分布式锁吗？有哪些实现方案？你谈谈对 redis 分布式锁的理解， 删除key 的时候有什么问题？

锁的概述：
1、 JVM 层面的加锁， 就是单机版本
2、 分布式为服务架构，拆分后各个为服务之间为了避免冲突和数据故障而加的一种锁，分布式锁

上面两种是两个不同的概念

分布式锁的实现：
1、mysql
2、zookeeper
3、redis

一般的互联网公司，都是喜欢使用 redis 来作为分布式锁

核心概览：
redis --- redlock ===> redisson lock/unlock
如果我们自己写：setnx + lua 脚本
开源实现： redisCluster -- redisson

分布式锁的常见问题和思考！

1、redis 除了拿来组缓存，还有那些基于 redis 的什么用法？
2、redis 做分布式锁的时候有需要注意的问题？
3、如果 redis 是单点部署，会带来什么问题？
4、集群模式下，比如主从模式，有没有什么问题？
5、你简单的介绍一下 redlock ， 看看你的理解？
6、redis 分布式锁如何续期，如何理解看门狗概念？

实践案例 (Spring Boot + Redis)

使用场景：

多个服务之间 + 保证同一个时刻内，同一个用户只能有一个请求（防止关键业务出现数据冲突和并发错误）

依赖文件

plugins {
    id 'org.springframework.boot' version '2.6.3'
    id 'io.spring.dependency-management' version '1.0.11.RELEASE'
    id 'java'
}

group 'io.zhengsh'
version '1.0-SNAPSHOT'

repositories {
    mavenCentral()
    maven { url 'https://repo.spring.io/milestone' }
    maven { url 'https://repo.spring.io/snapshot' }
}

dependencies {
    //implementation 'org.springframework.boot:spring-boot-starter'
    implementation 'org.springframework.boot:spring-boot-starter-web'
    implementation 'org.springframework.boot:spring-boot-starter-actuator'
    implementation 'org.springframework.boot:spring-boot-starter-aop'

    implementation 'org.springframework.boot:spring-boot-starter-data-redis'
    implementation 'org.apache.commons:commons-pool2'

    //implementation 'org.redisson:redisson-spring-boot-starter:3.16.8'

    testImplementation 'org.springframework.boot:spring-boot-starter-test'
}

tasks.named('test') {
    useJUnitPlatform()
}

YML 配置

server:
  port: 11111

spring:
  redis:
    database: 0
    host: 127.0.0.1
    passowrd:
    lettuce:
      pool:
        max-active: 8
        max-wait: -1
        max-idle: 8
        min-idle: 0

Redis 配置类

@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String, Serializable> redisTemplate(LettuceConnectionFactory lettuceConnectionFactory) {
        RedisTemplate<String, Serializable> redisTemplate = new RedisTemplate<>();

        redisTemplate.setConnectionFactory(lettuceConnectionFactory);

        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());

        return redisTemplate;
    }
}

Controller 控制器

@RestController
public class GoodsController {

    private Logger logger = LoggerFactory.getLogger(GoodsController.class);

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @Value("${server.port}")
    private Integer serverPort;

    @GetMapping("/byGoods")
    public String buyGoods() {
        String result = stringRedisTemplate.opsForValue().get("goods:001");
        int goodsNumber = result == null ? 0 : Integer.valueOf(result);
        if (goodsNumber > 0) {
            int realNumber = goodsNumber - 1;
            stringRedisTemplate.opsForValue().set("goods:001", String.valueOf(realNumber));
            logger.info("成功买到商品， 库存还剩下：{} 件｜服务提供者 serverPort : {}", realNumber, serverPort);
            return "成功买到商品， 库存还剩下：" + realNumber + " 件｜服务提供者 serverPort : " + serverPort;
        }
        logger.info("商品已经售完/活动结束/调用超时, 欢迎下次光临, serverPort:{}", serverPort);
        return "商品已经售完/活动结束/调用超时, 欢迎下次光临, serverPort:" + serverPort;
    }
}

启动类文件

@SpringBootApplication
public class App {

    public static void main(String[] args) {
        SpringApplication.run(App.class, args);
    }
}

接口访问

对于之前案例的一些问题思考

自定义 Redis 分布式锁

思考1: 单机锁/JVM 锁解决并发

单机版本没有加锁

• 没有加锁，并发下数字不对，出现超卖现象

加锁的思考：

• 加 synchronized 锁？ 还是加 ReentrantLock 锁？ 还是都可以？
• 对于 synchronized 锁 和 ReentrantLock 锁使用需要区分场景。

ReentrantLock 支持 tryLock ，以及设置锁超时的时间。相对非常灵活。

思考2:分布式环境下增加自定义分布式锁

nignx 负载均衡

• 分布式部署之后，单机锁还是出现超卖的情况，需要分布式锁

Niginx 配置负载均衡

1、启动 Nginx 并测试通过

2、/usr/local/nginx/conf/nginx.conf

nignx.conf 配置文件

3、重启 ./nginx -s reload

4、/usr/local/nginx/sbin/nginx -c /usr/local/nginx/cofig/nginx.conf

5、./nginx -c /usr/local/nginx/conf/nginx.conf

6、启动 /usr/local/nginx/sbin

7、关闭 /usr/local/nginx/sbin --> ./nginx -s stop

8、重启 ./nginx -s reload

启动两个服务

模拟高并发模拟

解决方案

上 redis 分布式锁

官网： redis.io/commands/se…

继续修改我们的代码：

@GetMapping("/buyGoods")
public String buyGoods() {
    String value = UUID.randomUUID().toString() + Thread.currentThread().getName();

    Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(REDIS_LOCK, value);//NX
    if (Boolean.FALSE.equals(flag)) {
        logger.info("抢锁失败, serverPort:{}", serverPort);
        return "抢锁失败";
    }

    String result = stringRedisTemplate.opsForValue().get("goods:001");
    int goodsNumber = result == null ? 0 : Integer.valueOf(result);
    if (goodsNumber > 0) {
        int realNumber = goodsNumber - 1;
        stringRedisTemplate.opsForValue().set("goods:001", String.valueOf(realNumber));
        logger.info("成功买到商品， 库存还剩下：{} 件｜服务提供者 serverPort : {}", realNumber, serverPort);

        stringRedisTemplate.delete(REDIS_LOCK);
        return "成功买到商品， 库存还剩下：" + realNumber + " 件｜服务提供者 serverPort : " + serverPort;
    }
    logger.info("商品已经售完/活动结束/调用超时, 欢迎下次光临, serverPort:{}", serverPort);
    return "商品已经售完/活动结束/调用超时, 欢迎下次光临, serverPort:" + serverPort;
}

思考3: 自定义分布式锁释放失败

上面代码的问题，如果出现异常，可能无法释放锁，所以锁的的释放，我们可以在 finally 代码块中释放。

---

加锁解锁， lock/unlock 必须同时出现并且保存，

代码优化如下：

@GetMapping("/buyGoods")
public String buyGoods() {
    try {
        String value = UUID.randomUUID().toString() + Thread.currentThread().getName();
        // 加锁
        Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(REDIS_LOCK, value);//NX
        if (Boolean.FALSE.equals(flag)) {
            logger.info("抢锁失败, serverPort:{}", serverPort);
            return "抢锁失败";
        }

        String result = stringRedisTemplate.opsForValue().get("goods:001");
        int goodsNumber = result == null ? 0 : Integer.valueOf(result);
        if (goodsNumber > 0) {
            int realNumber = goodsNumber - 1;
            stringRedisTemplate.opsForValue().set("goods:001", String.valueOf(realNumber));
            logger.info("成功买到商品， 库存还剩下：{} 件｜服务提供者 serverPort : {}", realNumber, serverPort);


            return "成功买到商品， 库存还剩下：" + realNumber + " 件｜服务提供者 serverPort : " + serverPort;
        }
        logger.info("商品已经售完/活动结束/调用超时, 欢迎下次光临, serverPort:{}", serverPort);
        return "商品已经售完/活动结束/调用超时, 欢迎下次光临, serverPort:" + serverPort;
    } finally {
        // 解锁
        stringRedisTemplate.delete(REDIS_LOCK);
    }
}

思考4: 加锁失败后宕机无法解锁

如果发生宕机情况下，可能是加锁成功？

部署了为为服务的 node 节点机器挂了，代码层面没有走到 finally这一步，没有保证解锁，这个 key 没有被删除，需要加入一个过期时间限定 key 。

解决方案：

try {
    String value = UUID.randomUUID().toString() + Thread.currentThread().getName();
    // 加锁
    Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(REDIS_LOCK, value);//NX
    // 10s 过期 (新增逻辑)
    stringRedisTemplate.expire(REDIS_LOCK, 10L, TimeUnit.SECONDS);
    if (Boolean.FALSE.equals(flag)) {
        logger.info("抢锁失败, serverPort:{}", serverPort);
        return "抢锁失败";
    }

    String result = stringRedisTemplate.opsForValue().get("goods:001");
    int goodsNumber = result == null ? 0 : Integer.valueOf(result);
    if (goodsNumber > 0) {
        int realNumber = goodsNumber - 1;
        stringRedisTemplate.opsForValue().set("goods:001", String.valueOf(realNumber));
        logger.info("成功买到商品， 库存还剩下：{} 件｜服务提供者 serverPort : {}", realNumber, serverPort);


        return "成功买到商品， 库存还剩下：" + realNumber + " 件｜服务提供者 serverPort : " + serverPort;
    }
    logger.info("商品已经售完/活动结束/调用超时, 欢迎下次光临, serverPort:{}", serverPort);
    return "商品已经售完/活动结束/调用超时, 欢迎下次光临, serverPort:" + serverPort;
} finally {
    // 解锁
    stringRedisTemplate.delete(REDIS_LOCK);
}

思考5: 加锁和设置锁的有效期如何保证事务

问题：设置 key + 过期时间分开了，必须要合并成一行，具备原子性

再次优化后的代码如下：

@GetMapping("/buyGoods")
public String buyGoods() {
    try {
        String value = UUID.randomUUID().toString() + Thread.currentThread().getName();
        // 加锁
        //Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(REDIS_LOCK, value);//NX
        // 10s 过期
        // stringRedisTemplate.expire(REDIS_LOCK, 10L, TimeUnit.SECONDS);
        Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(REDIS_LOCK, value, 10L, TimeUnit.SECONDS);//NX
        if (Boolean.FALSE.equals(flag)) {
            logger.info("抢锁失败, serverPort:{}", serverPort);
            return "抢锁失败";
        }

        String result = stringRedisTemplate.opsForValue().get("goods:001");
        int goodsNumber = result == null ? 0 : Integer.valueOf(result);
        if (goodsNumber > 0) {
            int realNumber = goodsNumber - 1;
            stringRedisTemplate.opsForValue().set("goods:001", String.valueOf(realNumber));
            logger.info("成功买到商品， 库存还剩下：{} 件｜服务提供者 serverPort : {}", realNumber, serverPort);


            return "成功买到商品， 库存还剩下：" + realNumber + " 件｜服务提供者 serverPort : " + serverPort;
        }
        logger.info("商品已经售完/活动结束/调用超时, 欢迎下次光临, serverPort:{}", serverPort);
        return "商品已经售完/活动结束/调用超时, 欢迎下次光临, serverPort:" + serverPort;
    } finally {
        // 解锁
        stringRedisTemplate.delete(REDIS_LOCK);
    }
}

思考6:防止张冠李戴，删除了别人的锁

问题：张冠李戴，删除了别人的锁

解决方案：只能删除自己的锁，别人的锁不能动

@GetMapping("/buyGoods")
public String buyGoods() {
    String value = UUID.randomUUID().toString() + Thread.currentThread().getName();
    try {
        // 加锁
        //Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(REDIS_LOCK, value);//NX
        // 10s 过期
        // stringRedisTemplate.expire(REDIS_LOCK, 10L, TimeUnit.SECONDS);
        Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(REDIS_LOCK, value, 10L, TimeUnit.SECONDS);//NX
        if (Boolean.FALSE.equals(flag)) {
            logger.info("抢锁失败, serverPort:{}", serverPort);
            return "抢锁失败";
        }

        String result = stringRedisTemplate.opsForValue().get("goods:001");
        int goodsNumber = result == null ? 0 : Integer.valueOf(result);
        if (goodsNumber > 0) {
            int realNumber = goodsNumber - 1;
            stringRedisTemplate.opsForValue().set("goods:001", String.valueOf(realNumber));
            logger.info("成功买到商品， 库存还剩下：{} 件｜服务提供者 serverPort : {}", realNumber, serverPort);


            return "成功买到商品， 库存还剩下：" + realNumber + " 件｜服务提供者 serverPort : " + serverPort;
        }
        logger.info("商品已经售完/活动结束/调用超时, 欢迎下次光临, serverPort:{}", serverPort);
        return "商品已经售完/活动结束/调用超时, 欢迎下次光临, serverPort:" + serverPort;
    } finally {
        // 解锁
        if (Objects.equals(stringRedisTemplate.opsForValue().get(REDIS_LOCK), value)) {
            stringRedisTemplate.delete(REDIS_LOCK);
        }
    }
}

思考7: 解锁过程的原子性/保证事务

问题：

finally 块的判断 + del 删除操作不是原子性的

// 解锁, 判断加锁与解锁不是同一个客户端
if (Objects.equals(stringRedisTemplate.opsForValue().get(REDIS_LOCK), value)) {
    // 若在此时，这把锁不是这个客户端的，则会错误的解锁
    stringRedisTemplate.delete(REDIS_LOCK);
}

解决方案，不用 lua 脚本，其他的操作

• redis 本身的事务

事务介绍

• redis 的事务是通过 MULTI、EXEC、DISCARD 和 WATCH 这四个命令来完成的。
• redis 的单个命令都是原子性的，所以这里确保事务性的对象是命令集合。
• redis 将命令集合序列化确保处于一事务的命令集合连续且不被打断的执行。
• redis 不支持回滚的操作

相关命令

序号	命令及描述
1	DISCARD 取消事务，放弃执行事务块内的所有命令。
2	EXEC 执行所有事务块内的命令。
3	MULTI 标记一个事务块的开始。
4	UNWATCH 取消 WATCH 命令对所有 key 的监视。
5	WATCH key [key ...] 监视一个(或多个) key ，如果在事务执行之前这个(或这些) key 被其他命令所改动，那么事务将被打断。

命令执行

redis 自身的事务优化

@GetMapping("/buyGoods")
public String buyGoods() {
    String value = UUID.randomUUID().toString() + Thread.currentThread().getName();
    try {
        // 加锁
        //Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(REDIS_LOCK, value);//NX
        // 10s 过期
        // stringRedisTemplate.expire(REDIS_LOCK, 10L, TimeUnit.SECONDS);
        Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(REDIS_LOCK, value, 10L, TimeUnit.SECONDS);//NX
        if (Boolean.FALSE.equals(flag)) {
            logger.info("抢锁失败, serverPort:{}", serverPort);
            return "抢锁失败";
        }

        String result = stringRedisTemplate.opsForValue().get("goods:001");
        int goodsNumber = result == null ? 0 : Integer.valueOf(result);
        if (goodsNumber > 0) {
            int realNumber = goodsNumber - 1;
            stringRedisTemplate.opsForValue().set("goods:001", String.valueOf(realNumber));
            logger.info("成功买到商品， 库存还剩下：{} 件｜服务提供者 serverPort : {}", realNumber, serverPort);


            return "成功买到商品， 库存还剩下：" + realNumber + " 件｜服务提供者 serverPort : " + serverPort;
        }
        logger.info("商品已经售完/活动结束/调用超时, 欢迎下次光临, serverPort:{}", serverPort);
        return "商品已经售完/活动结束/调用超时, 欢迎下次光临, serverPort:" + serverPort;
    } finally {
        // redis 事务
        while (true) {
            stringRedisTemplate.watch(REDIS_LOCK);
            if (Objects.equals(stringRedisTemplate.opsForValue().get(REDIS_LOCK), value)) {
                stringRedisTemplate.setEnableTransactionSupport(true);
                stringRedisTemplate.multi();
                stringRedisTemplate.delete(REDIS_LOCK);
                List<Object> list = stringRedisTemplate.exec();
                if (CollectionUtils.isEmpty(list)) {
                    continue;
                }
            }
            stringRedisTemplate.unwatch();
            break;
        }
    }
}

通过 lua 脚本的方式来删除

    @GetMapping("/buyGoods")
    public String buyGoods() {
        String value = UUID.randomUUID().toString() + Thread.currentThread().getName();
        try {
            // 加锁
            //Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(REDIS_LOCK, value);//NX
            // 10s 过期
            // stringRedisTemplate.expire(REDIS_LOCK, 10L, TimeUnit.SECONDS);
            Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(REDIS_LOCK, value, 10L, TimeUnit.SECONDS);//NX
            if (Boolean.FALSE.equals(flag)) {
                logger.info("抢锁失败, serverPort:{}", serverPort);
                return "抢锁失败";
            }

            String result = stringRedisTemplate.opsForValue().get("goods:001");
            int goodsNumber = result == null ? 0 : Integer.valueOf(result);
            if (goodsNumber > 0) {
                int realNumber = goodsNumber - 1;
                stringRedisTemplate.opsForValue().set("goods:001", String.valueOf(realNumber));
                logger.info("成功买到商品， 库存还剩下：{} 件｜服务提供者 serverPort : {}", realNumber, serverPort);


                return "成功买到商品， 库存还剩下：" + realNumber + " 件｜服务提供者 serverPort : " + serverPort;
            }
            logger.info("商品已经售完/活动结束/调用超时, 欢迎下次光临, serverPort:{}", serverPort);
            return "商品已经售完/活动结束/调用超时, 欢迎下次光临, serverPort:" + serverPort;
        } finally {
            // 解锁
            /*
            if (Objects.equals(stringRedisTemplate.opsForValue().get(REDIS_LOCK), value)) {
                stringRedisTemplate.delete(REDIS_LOCK);
            }
            */

            /*
            while (true) {
                stringRedisTemplate.watch(REDIS_LOCK);
                if (Objects.equals(stringRedisTemplate.opsForValue().get(REDIS_LOCK), value)) {
                    stringRedisTemplate.setEnableTransactionSupport(true);
                    stringRedisTemplate.multi();
                    stringRedisTemplate.delete(REDIS_LOCK);
                    List<Object> list = stringRedisTemplate.exec();
                    if (CollectionUtils.isEmpty(list)) {
                        continue;
                    }
                }
                stringRedisTemplate.unwatch();
                break;
            }
            */

            String RELEASE_LOCK_LUA_SCRIPT = "if redis.call("get",KEYS[1]) == ARGV[1] then\n" +
                    "    return redis.call("del",KEYS[1])\n" +
                    "else\n" +
                    "    return 0\n" +
                    "end";
            DefaultRedisScript<Long> redisScript =
                    new DefaultRedisScript<>(RELEASE_LOCK_LUA_SCRIPT, Long.class);
            // 参数一：redisScript，参数二：key列表，参数三：arg（可多个）
            Long result = stringRedisTemplate.execute(redisScript,
                    Collections.singletonList(REDIS_LOCK), value);
            if (Objects.equals(result, 1)) {
                logger.info(" ========> del redis lock ok!");
            } else {
                logger.info(" ========> del redis lock err!");
            }
        }
    }

思考8: 终极解决方案还是得用 redisson

确保 redislock 过期时间大于业务执行时间的问题

老身长谈的问题：redis 分布式锁如何续期

集群 + CAP 对比 zookeeper

• redis - ap ； redis 异步复制造成的锁丢失，比如：主节点还没来得及把刚刚 set 进来的这条数据给从节点，就挂了
• zookeeper - cp

总结

redis 集群环境下，我们字节写的也不 ok, 直接使用 redlock 之 redisson 落地实现

上 redisson

• 导入依赖

implementation 'org.redisson:redisson-spring-boot-starter:3.16.8'

• 配置类 （java）

@Bean
public Redisson redisson() {
    Config config = new Config();
    config.useSingleServer().setAddress("http://127.0.0.1:6379").setDatabase(0);
    return (Redisson) Redisson.create(config);
}

• 代码调整

@GetMapping("/buyGoods")
public String buyGoods() {
    RLock rLock = redisson.getLock(REDIS_LOCK);
    rLock.lock();
    try {
        String result = stringRedisTemplate.opsForValue().get("goods:001");
        int goodsNumber = result == null ? 0 : Integer.valueOf(result);
        if (goodsNumber > 0) {
            int realNumber = goodsNumber - 1;
            stringRedisTemplate.opsForValue().set("goods:001", String.valueOf(realNumber));
            logger.info("成功买到商品， 库存还剩下：{} 件｜服务提供者 serverPort : {}", realNumber, serverPort);


            return "成功买到商品， 库存还剩下：" + realNumber + " 件｜服务提供者 serverPort : " + serverPort;
        }
        logger.info("商品已经售完/活动结束/调用超时, 欢迎下次光临, serverPort:{}", serverPort);
        return "商品已经售完/活动结束/调用超时, 欢迎下次光临, serverPort:" + serverPort;
    } finally {
        if (rLock.isLocked() && rLock.isHeldByCurrentThread()) {
            rLock.unlock();
        }
    }
}

Redis 分布式锁总结

1、synchronized 可以解决单机问题，但是对于我们生产分布式环境，需要通分布式锁来解决数据操作的原子性

2、通过 niginx 来建立分分布式微服务环境（验证单机锁的问题）

3、取消单机锁，上 redis 分布式锁 setnx

4、只是加锁，没有释放锁，对于出现异常的情况，可能无法释放锁，必须要在代码层面 finally 释放锁

5、宕机了，部署了微服务代码层面根本没有走 finally 中的代码语句，没有保证解锁，这个 key 没有被删除，所以我们需要有 lockKey 的过期时间设定

6、为 redis 的分布式锁 key , 增加过期时间，此外，还必须要 setnx + 过期时间必须同一行

7、必须规定只能自己删除自己的锁，你不能把别人的的锁删除了，防止张冠李戴

1 删 2 ， 2 删 3.

8、redis 集群环境下，我们自己写的也不 ok 直接上 redlock 之 redisson 落地实现。