redis原生分布式锁java

原创

mob64ca12f37e8a 2024-01-29 11:00:14 ©著作权

文章标签 分布式锁 Redis System 文章分类 Redis 数据库

©著作权归作者所有：来自51CTO博客作者mob64ca12f37e8a的原创作品，请联系作者获取转载授权，否则将追究法律责任

Redis原生分布式锁Java实现

引言

在分布式系统中，由于多个节点之间的并行处理，往往需要对共享资源进行加锁，以保证数据的一致性和正确性。Redis作为一种高性能的键值存储系统，提供了原生的分布式锁实现。本文将介绍如何使用Java语言结合Redis原生命令实现分布式锁。

Redis原生分布式锁

Redis的分布式锁是通过使用命令集合的方式实现的。我们可以使用两个命令来实现分布式锁：SETNX 和 EXPIRE。

SETNX 命令用于在 Redis 中设置一个键值对，如果这个键不存在，则设置成功，返回 1；如果这个键已经存在，则设置失败，返回 0。
EXPIRE 命令用于设置键的过期时间。

基于上述命令，我们可以将分布式锁的实现分为两个步骤：

获取锁：使用 SETNX 命令尝试在 Redis 中设置一个键，如果设置成功，则获取到锁。
释放锁：使用 DEL 命令删除 Redis 中的键，释放锁。

Java实现示例

下面是一个使用Java语言结合Redis原生命令实现的分布式锁示例：

import redis.clients.jedis.Jedis;

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

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

    public boolean acquireLock() {
        Long result = jedis.setnx(lockKey, "locked");

        if (result == 1) {
            jedis.expire(lockKey, expireTime);
            return true;
        }

        return false;
    }

    public void releaseLock() {
        jedis.del(lockKey);
    }
}

上述代码中，我们定义了一个 RedisDistributedLock 类，它接受一个连接到 Redis 的 Jedis 对象，锁的键名和过期时间作为参数。acquireLock 方法尝试获取锁，如果成功获取到锁，则返回 true，否则返回 false。releaseLock 方法用于释放锁。

使用示例

下面是一个使用示例，展示了如何在一个多线程环境中使用分布式锁：

import redis.clients.jedis.Jedis;

public class Example {
    private static final Jedis jedis = new Jedis("localhost");

    public static void main(String[] args) {
        RedisDistributedLock lock = new RedisDistributedLock(jedis, "mylock", 60);

        Thread thread1 = new Thread(() -> {
            if (lock.acquireLock()) {
                System.out.println("Thread 1 acquired the lock");
                try {
                    Thread.sleep(5000); // 模拟操作共享资源的过程
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                lock.releaseLock();
                System.out.println("Thread 1 released the lock");
            } else {
                System.out.println("Thread 1 failed to acquire the lock");
            }
        });

        Thread thread2 = new Thread(() -> {
            if (lock.acquireLock()) {
                System.out.println("Thread 2 acquired the lock");
                try {
                    Thread.sleep(5000); // 模拟操作共享资源的过程
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                lock.releaseLock();
                System.out.println("Thread 2 released the lock");
            } else {
                System.out.println("Thread 2 failed to acquire the lock");
            }
        });

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

在上述示例中，我们创建了两个线程，每个线程都尝试获取锁并操作共享资源。由于分布式锁的特性，只有一个线程能够成功获取到锁，并进入临界区操作共享资源。另一个线程获取锁失败，需要等待第一个线程释放锁后才能再次尝试获取。