Java如何使用 Redis 实现分布式锁

在构建分布式系统时，分布式锁是一个非常关键的组件。今天，我们来聊聊如何在 Redis 中实现分布式锁，尤其是通过 setnx 命令和一些额外措施来确保锁的可靠性。

1. 使用 setnx 加过期时间实现分布式锁

首先，我们可以通过 Redis 的 setnx 命令来实现基本的分布式锁。setnx 是 “set if not exists” 的缩写，它会在指定的键不存在时才进行设置，这样就确保了锁的唯一性。代码如下：

@Override
public void testLock() {
    // 尝试获取锁
    Boolean ifAbsent = redisTemplate.opsForValue().setIfAbsent("lock", "lock");

    // 如果获取到锁，执行相应的业务逻辑
    if (ifAbsent) {
        // 从 Redis 中获取当前的数值
        String value = redisTemplate.opsForValue().get("num");
        if (StringUtils.isBlank(value)) {
            return;
        }
        // 将值加一并存回 Redis
        int num = Integer.parseInt(value);
        redisTemplate.opsForValue().set("num", String.valueOf(++num));

        // 业务逻辑执行完毕，释放锁
        redisTemplate.delete("lock");
    } else {
        // 未获取到锁时，等待一段时间后重试
        try {
            Thread.sleep(100);
            this.testLock();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

问题：
如果在业务执行过程中出现异常，锁可能无法被正常释放，从而导致死锁。

解决方案：
为锁设置一个过期时间，确保锁能够自动释放。

// 获取锁并设置过期时间
Boolean ifAbsent = redisTemplate.opsForValue()
                 .setIfAbsent("lock", "lock", 10, TimeUnit.SECONDS);

2. 使用 UUID 防止锁误删

虽然我们通过设置过期时间解决了锁无法释放的问题，但还有另一个隐患：锁可能会被误删。假设业务逻辑执行的时间较长，锁在业务执行过程中自动过期并被新的请求获取，这时原来的请求在完成后释放锁，可能会误删其他请求持有的锁。

为了解决这个问题，我们可以在加锁时为锁的值设置一个唯一标识符（如 UUID），并在释放锁时验证该标识符是否匹配。代码如下：

@Override
public void testLock() {
    String uuid = UUID.randomUUID().toString();
    Boolean ifAbsent = redisTemplate.opsForValue()
                    .setIfAbsent("lock", uuid, 3, TimeUnit.SECONDS);

    if (ifAbsent) {
        String value = redisTemplate.opsForValue().get("num");
        if (StringUtils.isBlank(value)) {
            return;
        }
        int num = Integer.parseInt(value);
        redisTemplate.opsForValue().set("num", String.valueOf(++num));

        // 释放锁时，先检查锁的标识符是否匹配
        String redisUuid = redisTemplate.opsForValue().get("lock");
        if (uuid.equals(redisUuid)) {
            redisTemplate.delete("lock");
        }
    } else {
        try {
            Thread.sleep(100);
            this.testLock();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

3. 使用 LUA 脚本保证操作的原子性

即使使用 UUID 防止误删锁，还是会有一个问题：获取锁和释放锁的操作并不具备原子性，可能在并发环境下出现竞态条件。为了彻底解决这个问题，我们可以使用 Redis 的 LUA 脚本来保证这些操作的原子性。LUA 脚本可以将获取锁和释放锁的逻辑合并为一个原子操作，代码如下：

@Override
public void testLock() {
    String uuid = UUID.randomUUID().toString();
    Boolean ifAbsent = redisTemplate.opsForValue()
                    .setIfAbsent("lock", uuid, 3, TimeUnit.SECONDS);

    if (ifAbsent) {
        String value = redisTemplate.opsForValue().get("num");
        if (StringUtils.isBlank(value)) {
            return;
        }
        int num = Integer.parseInt(value);
        redisTemplate.opsForValue().set("num", String.valueOf(++num));

        // 使用 LUA 脚本来释放锁，确保操作的原子性
        DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>();
        String script = "if redis.call(\"get\",KEYS[1]) == ARGV[1] then return redis.call(\"del\",KEYS[1]) else return 0 end";
        redisScript.setScriptText(script);
        redisScript.setResultType(Long.class);
        redisTemplate.execute(redisScript, Arrays.asList("lock"), uuid);
    } else {
        try {
            Thread.sleep(100);
            this.testLock();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

4. 总结

要实现一个可靠的分布式锁，我们需要确保锁的实现满足以下几个关键条件：

1. 互斥性：任何时刻只有一个客户端能持有锁。
2. 不会发生死锁：即使客户端崩溃，锁也能被其他客户端获取。
3. 解铃还须系铃人：加锁和解锁必须由同一个客户端完成。
4. 操作具备原子性：加锁和解锁的操作需要是原子的，不能被打断。

通过 Redis 的 setnx 命令配合过期时间、UUID 以及 LUA 脚本，我们可以构建一个可靠的分布式锁，满足上述所有条件。这种锁在高并发环境下能够有效防止资源竞争，保证系统的稳定性。