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 脚本,我们可以构建一个可靠的分布式锁,满足上述所有条件。这种锁在高并发环境下能够有效防止资源竞争,保证系统的稳定性。

你可能感兴趣的:(java,redis,分布式)