Redis 分布式锁实现详解

在分布式系统中，我们需要解决的一个重要问题是多个服务实例之间如何协调共享资源的访问问题。例如，在电子商务系统中，库存更新需要被多个微服务实例所共享，但为了防止超卖，必须确保库存更新是原子性的。这就是分布式锁发挥作用的地方。

本文将介绍如何使用 Redis 实现一个简单的分布式锁，并提供完整的 Java 代码示例。

1. 前置知识

Redis：一个开源的键值存储系统，支持多种数据结构，如字符串、哈希表等。
Jedis：一个用于 Redis 的 Java 客户端库。
Java：本示例使用 Java 编程语言。

2. 设计思路

2.1 锁的获取与释放

我们可以通过 Redis 的 SET 命令来实现锁的获取和释放：

使用 SETNX（Set if Not eXists）命令来尝试获取锁。
使用 EXPIRE 命令为锁设置过期时间，以避免死锁。
使用 DEL 命令来释放锁。

2.2 锁的重入性

为了避免线程 A 获取了锁之后，线程 B 冒充线程 A 来释放锁，我们可以给每个线程分配一个唯一的标识符，这个标识符可以是线程 ID 或者是 UUID。这样，在释放锁的时候，需要检查锁的持有者是否是当前线程。

2.3 锁的自动释放

如果获取锁的客户端异常退出或者网络中断，锁应该能够自动释放。为此，我们需要给锁设置一个过期时间。

3. 代码实现

3.1 添加依赖

首先，确保你的项目中有 Jedis 的依赖。如果你使用 Maven，可以在 pom.xml 文件中添加以下依赖：

xml 复制代码

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>3.10.0</version>
</dependency>

3.2 RedisDistributedLock 类

接下来，我们将创建一个 RedisDistributedLock 类来实现上述逻辑。

java 复制代码

import redis.clients.jedis.Jedis;

public class RedisDistributedLock {
    private final Jedis jedis;
    private final String lockKey;
    private final int lockTimeoutSeconds;
    private String identifier;

    public RedisDistributedLock(Jedis jedis, String lockKey, int lockTimeoutSeconds) {
        this.jedis = jedis;
        this.lockKey = lockKey;
        this.lockTimeoutSeconds = lockTimeoutSeconds;
    }

    public boolean tryLock() {
        identifier = UUID.randomUUID().toString();
        Long result = jedis.setnx(lockKey, identifier);
        if (result == 1L) {
            // Set the lock timeout to avoid deadlocks
            jedis.expire(lockKey, lockTimeoutSeconds);
            return true;
        }
        return false;
    }

    public void unlock() {
        String currentValue = jedis.get(lockKey);
        if (currentValue != null && currentValue.equals(identifier)) {
            jedis.del(lockKey);
        }
    }
}

3.3 测试代码

下面是一个简单的测试类来验证我们的锁机制是否有效。

java 复制代码

public class LockTest {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("localhost", 6379);
        RedisDistributedLock lock = new RedisDistributedLock(jedis, "test_lock", 10);

        Thread thread1 = new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + " is trying to acquire the lock.");
            if (lock.tryLock()) {
                try {
                    System.out.println(Thread.currentThread().getName() + " has acquired the lock.");
                    Thread.sleep(5000); // Simulate some work
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                    System.out.println(Thread.currentThread().getName() + " has released the lock.");
                }
            } else {
                System.out.println(Thread.currentThread().getName() + " failed to acquire the lock.");
            }
        });

        Thread thread2 = new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + " is trying to acquire the lock.");
            if (lock.tryLock()) {
                try {
                    System.out.println(Thread.currentThread().getName() + " has acquired the lock.");
                    Thread.sleep(5000); // Simulate some work
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                    System.out.println(Thread.currentThread().getName() + " has released the lock.");
                }
            } else {
                System.out.println(Thread.currentThread().getName() + " failed to acquire the lock.");
            }
        });

        thread1.start();
        thread2.start();
    }
}

这段代码创建了两个线程，试图同时获取锁。运行该程序，你会看到只有一个线程成功获取了锁，而另一个线程则无法获取锁。

4. 总结

通过上述实现，我们已经构建了一个基本的 Redis 分布式锁。在实际应用中，你可能还需要考虑更多的场景和细节，比如锁的续期、异常处理等。希望这篇博客能为你提供一个良好的起点！