Redis 实现分布式锁

问题描述

随着业务发展的需要，原单体单机部署的系统被演化成分布式集群系统后，由于分布式系统多线程、多进程并且分布在不同机器上，这将使原单机部署情况下的并发控制锁策略失效，单纯的Java API并不能提供分布式锁的能力。为了解决这个问题就需要一种跨JVM的互斥机制来控制共享资源的访问，这就是分布式锁要解决的问题！

---

分布式锁主流的实现方案：

1. 基于数据库实现分布式锁
2. 基于缓存（Redis等）
3. 基于Zookeeper

---

每一种分布式锁解决方案都有各自的优缺点：

• 性能：redis最高
• 可靠性：zookeeper最高

这里，我们就基于redis实现分布式锁。

---

思路分析

主要使用 redis 中的一个命令 setnx 这个命令主要含义就是，只有 key 不存在的时候，才对 key 进行设置操作；否则不进行任何操作。

• 多个客户端同时获取锁（setnx）
• 其中一个获取到锁之后，执行业务逻辑{从 db 中获取数据，放入缓存}，执行完成释放锁（del）
• 其他客户端等待重试

代码实现

 @GetMapping("/testLock")
    public void testLock() throws InterruptedException {
        //1.获取锁
        Boolean lock = redisTemplate.opsForValue().setIfAbsent("locks", "1111");
        //2.进行业务处理 对 num 值进行处理
        if (lock) {
            Object value = redisTemplate.opsForValue().get("num");
            //2.1判断num为空return
            if (StringUtils.isEmpty(value)) {
                return;
            }
            //2.2有值就转成成int
            int num = Integer.parseInt(String.valueOf(value));
            //2.3把redis的num加1
            redisTemplate.opsForValue().set("num", ++num);
            
            //2.4释放锁，del,进行判断
                redisTemplate.delete("lock");
    
        } else {
            //3获取锁失败、每隔0.1秒再获取
            try {
                Thread.sleep(100);
                testLock();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

---

以上代码存在问题：

如果 setnx 刚好获取到锁，业务逻辑出现异常，导致锁无法释放，造成死锁，该如何解决。

解决办法：
	设置 key 的过期时间，自动释放锁。

设置过期时间有两种方式：

1. 首先想到通过expire设置过期时间（缺乏原子性：如果在setnx和expire之间出现异常，锁也无法释放）
2. 在set时指定过期时间（推荐）

---

---

代码优化 1

@GetMapping("/testLock")
public void testLock() throws InterruptedException {
        //1.获取锁
        Boolean lock = redisTemplate.opsForValue().setIfAbsent("locks", "111", 10, TimeUnit.SECONDS);
        //2.进行业务处理 对 num 值进行处理
        if (lock) {
            Object value = redisTemplate.opsForValue().get("num");
            //2.1判断num为空return
            if (StringUtils.isEmpty(value)) {
                return;
            }
            //2.2有值就转成成int
            int num = Integer.parseInt(String.valueOf(value));
            //2.3把redis的num加1
            redisTemplate.opsForValue().set("num", ++num);
            //2.4释放锁，del,进行判断
            redisTemplate.delete("lock");
        } else {
            //3获取锁失败、每隔0.1秒再获取
            try {
                Thread.sleep(100);
                testLock();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

---

以上代码还存在问题：

可能会释放其他服务器的锁

场景：如果业务逻辑的执行时间是 7s ，执行流程如下：

1. index1业务逻辑没执行完，3秒后锁被自动释放。
2. index2获取到锁，执行业务逻辑，3秒后锁被自动释放。
3. index3获取到锁，执行业务逻辑
4. index1业务逻辑执行完成，开始调用del释放锁，这时释放的是index3的锁，导致index3的业务只执行1s就被别人释放。

最终等于没锁的情况。

---

解决方案：
	setnx获取锁时，设置一个指定的唯一值（例如：uuid）；释放前获取这个值，判断是否自己的锁

---

使用 UUID 防误删

代码优化 2

@GetMapping("/testLock")
    public void testLock() throws InterruptedException {

        String uuid = UUID.randomUUID().toString();
        //1.获取锁
        Boolean lock = redisTemplate.opsForValue().setIfAbsent("locks", uuid, 10, TimeUnit.SECONDS);
        //2.进行业务处理 对 num 值进行处理
        if (lock) {
            Object value = redisTemplate.opsForValue().get("num");
            //2.1判断num为空return
            if (StringUtils.isEmpty(value)) {
                return;
            }
            //2.2有值就转成成int
            int num = Integer.parseInt(String.valueOf(value));
            //2.3把redis的num加1
            redisTemplate.opsForValue().set("num", ++num);
            //2.4释放锁，del,进行判断
            if (uuid.equals((String) redisTemplate.opsForValue().get("locks"))){
                redisTemplate.delete("lock");
            }

        } else {
            //3获取锁失败、每隔0.1秒再获取
            try {
                Thread.sleep(100);
                testLock();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }

---

以上代码还是存在问题：

删除操作缺乏 原子性

场景：

1. index1 执行删除操作时，查询到的 lock 值确实和 uuid 相等

2. index1 在执行删除前，还没有删除时，lock 刚好过期时间到了，被redis 自动释放锁，在 redis 中没有了 lock，没有了锁

3. 此时，index2 获取到了 lock

4. index1 执行删除，此时会把 index2 的 lock 删除

   index1 因为已经在方法中了，所以不需要重新上锁。index1 有执行的权限。index1 已经比较完毕，这个时候就可以删除 lock，此时的锁却是 index2 的。

---

优化之LUA脚本保证删除的原子性

代码优化 3

 @GetMapping("/testLock")
    public void testLock() throws InterruptedException {

        String uuid = UUID.randomUUID().toString();
        String lockKey = "locks";
        //1.获取锁
        Boolean lock = redisTemplate.opsForValue().setIfAbsent(lockKey, uuid, 10, TimeUnit.SECONDS);
        //2.进行业务处理 对 num 值进行处理
        if (lock) {
            Object value = redisTemplate.opsForValue().get("num");
            //2.1判断num为空return
            if (StringUtils.isEmpty(value)) {
                return;
            }
            //2.2有值就转成int
            int num = Integer.parseInt(String.valueOf(value));
            //2.3把redis的num加1
            redisTemplate.opsForValue().set("num", ++num);

            // 定义lua 脚本
            String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
            // 使用redis执行lua执行
            DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>();
            redisScript.setScriptText(script);
            // 设置一下返回值类型 为Long
            // 因为删除判断的时候，返回的0,给其封装为数据类型。如果不封装那么默认返回String 类型，
            // 那么返回字符串与0 会有发生错误。
            redisScript.setResultType(Long.class);
            // 第一个要是script 脚本 ，第二个需要判断的key，第三个就是key所对应的值。
            redisTemplate.execute(redisScript, List.of(lockKey), uuid);

        } else {
            //3获取锁失败、每隔0.1秒再获取
            try {
                Thread.sleep(100);
                testLock();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }

---

LUA 脚本详解

客户端执行以上命令：

• 如果服务器返回 true，那么这个客户端获得锁
• 如果服务器返回 false，那么客户端获取锁失败，就可以稍后等待重试

设置的过期时间到达之后，锁将自动释放。

可以通过一下修改，让这个锁实现更健壮：

• 不使用固定的字符串作为键的值，而是设置一个不可猜测的长随机字符串，作为口令串（token）。
• 不使用 del命令来释放锁，而是发送一个 Lua 脚本，这个脚本只在客户端传入的值和键的口令串相匹配时，才进行删除。

这两个改动可以防止持有过期锁的客户端误删现有锁的情况

一下就是一个简单的解锁脚本实例：

if redis.call('get', KEYS[1]) == ARGV[1] 
then 
	return redis.call('del', KEYS[1]) 
else 
	return 0 
end

---

为了确保分布式锁可用，我们至少要满足一下四个条件：

• 互斥性。在任意时刻，只有一个客户端能持有锁。
• 不会发生死锁。即使有一个客户端在持有锁的期间崩溃而没有主动解锁，也能保证后续客户端能加锁
• 解铃还须系铃人。加锁和解锁必须是同一个客户端，客户端自己不能把别人加的锁给解了
• 加锁和解锁必须具有原子性