目录

前言:  

使用场景:

基于 Redis 实现分布式锁的详细示例：

使用示例：

依赖:

Redis分布式锁控制并发访问:

前言:  

   记录一些小笔记 , 如果对你有帮助 那就更好了

使用场景:

Redis 实现分布式锁的使用场景包括：

1. 防止重复操作：在分布式环境下，多个进程可能同时对同一个资源进行操作，为了避免重复操作，可以使用分布式锁来保证只有一个进程可以对资源进行操作。

2. 控制并发访问：在高并发场景下，多个进程同时访问同一个资源可能会导致性能问题，为了控制并发访问，可以使用分布式锁来限制同时访问的进程数量。

3. 保证数据一致性：在分布式事务场景下，需要保证多个操作的原子性，可以使用分布式锁来保证多个操作的顺序和一致性。

4. 避免死锁：在分布式环境下，多个进程可能同时获取锁，为了避免死锁，可以使用分布式锁来保证只有一个进程可以持有锁。

总之，分布式锁是在分布式环境下保证数据一致性和避免并发问题的重要工具，适用于各种分布式应用场景。

基于 Redis 实现分布式锁的详细示例：

import redis.clients.jedis.Jedis;
import redis.clients.jedis.params.SetParams;

public class RedisDistributedLock {
    private static final String LOCK_KEY = "lock_key";
    private static final int LOCK_EXPIRE_TIME = 30000; // 锁过期时间，单位毫秒
    private static final int SLEEP_TIME = 100; // 获取锁失败后，等待重试的时间，单位毫秒

    private Jedis jedis;

    public RedisDistributedLock(Jedis jedis) {
        this.jedis = jedis;
    }

    public boolean lock() {
        while (true) {
            SetParams params = new SetParams();
            params.nx();
            params.px(LOCK_EXPIRE_TIME);
            String result = jedis.set(LOCK_KEY, "locked", params);
            if ("OK".equals(result)) {
                return true;
            }
            try {
                Thread.sleep(SLEEP_TIME);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }

    public void unlock() {
        jedis.del(LOCK_KEY);
    }
}

在上面的示例中，我们使用了 Redis 的 SETNX 命令来实现分布式锁。当 SETNX 命令返回 1 时，表示成功获取到锁，否则表示锁已被其他进程占用，需要等待一段时间后重试。为了避免死锁，我们还设置了锁的过期时间，当锁过期后，其他进程可以重新获取锁。

使用示例：

import redis.clients.jedis.Jedis;

public class Main {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("localhost");
        RedisDistributedLock lock = new RedisDistributedLock(jedis);
        try {
            if (lock.lock()) {
                // 获取锁成功，执行业务逻辑
            } else {
                // 获取锁失败，处理异常情况
            }
        } finally {
            lock.unlock();
        }
    }
}

在实际应用中，我们需要根据具体的业务需求和系统架构来调整分布式锁的实现方式。例如，可以使用 Redis 的 Lua 脚本来实现原子性操作，或者使用 Redlock 算法来提高分布式锁的可靠性。

依赖:

上述代码需要依赖 Redis 的 Java 客户端库，例如 Jedis 或 Lettuce。以下是 Maven 依赖示例：

根据实际情况选择合适的 Redis 客户端库和版本。

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

<dependency>
    <groupId>io.lettuce</groupId>
    <artifactId>lettuce-core</artifactId>
    <version>6.1.3.RELEASE</version>
</dependency>
 

Redis分布式锁控制并发访问:

Redis 分布式锁可以用来控制并发访问，避免多个进程同时访问同一个资源导致的性能问题。具体来说，可以使用 Redis 分布式锁来限制同时访问某个资源的进程数量，例如：

1. 获取锁时，检查当前已经持有锁的进程数量，如果超过了限制数量，则等待一段时间后重试。

2. 在释放锁时，检查是否还有其他进程在等待锁，如果有，则唤醒其中一个进程继续执行。

下面是一个使用 Redis 分布式锁控制并发访问的示例：

import redis.clients.jedis.Jedis;
import redis.clients.jedis.params.SetParams;

public class RedisConcurrencyControl {
    private static final String LOCK_KEY = "lock_key";
    private static final int LOCK_EXPIRE_TIME = 30000; // 锁过期时间，单位毫秒
    private static final int SLEEP_TIME = 100; // 获取锁失败后，等待重试的时间，单位毫秒
    private static final int MAX_CONCURRENCY = 10; // 最大并发数

    private Jedis jedis;

    public RedisConcurrencyControl(Jedis jedis) {
        this.jedis = jedis;
    }

    public boolean acquireLock() {
        while (true) {
            SetParams params = new SetParams();
            params.nx();
            params.px(LOCK_EXPIRE_TIME);
            String result = jedis.set(LOCK_KEY, "locked", params);
            if ("OK".equals(result)) {
                return true;
            }
            try {
                Thread.sleep(SLEEP_TIME);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }

    public void releaseLock() {
        jedis.del(LOCK_KEY);
        String waitingKey = LOCK_KEY + "_waiting";
        String waitingCount = jedis.get(waitingKey);
        if (waitingCount != null) {
            int count = Integer.parseInt(waitingCount);
            if (count > 0) {
                jedis.decr(waitingKey);
                jedis.publish(waitingKey, "1");
            } else {
                jedis.del(waitingKey);
            }
        }
    }

    public boolean tryEnter() {
        String waitingKey = LOCK_KEY + "_waiting";
        String waitingCount = jedis.get(waitingKey);
        if (waitingCount == null) {
            jedis.set(waitingKey, "1");
            jedis.expire(waitingKey, LOCK_EXPIRE_TIME);
            return true;
        } else {
            int count = Integer.parseInt(waitingCount);
            if (count < MAX_CONCURRENCY) {
                jedis.incr(waitingKey);
                jedis.expire(waitingKey, LOCK_EXPIRE_TIME);
                return true;
            } else {
                return false;
            }
        }
    }

    public void waitEnter() {
        String waitingKey = LOCK_KEY + "_waiting";
        jedis.subscribe(new JedisPubSub() {
            @Override
            public void onMessage(String channel, String message) {
                synchronized (RedisConcurrencyControl.this) {
                    RedisConcurrencyControl.this.notifyAll();
                }
            }
        }, waitingKey);
    }
}

在上面的示例中，我们使用 Redis 分布式锁来控制最大并发数。在进程尝试访问资源时，首先需要获取锁，如果获取锁失败，则等待一段时间后重试。如果获取锁成功，则检查当前已经持有锁的进程数量，如果超过了最大并发数，则将自己加入等待队列，并等待其他进程释放锁后唤醒自己。在释放锁时，需要检查等待队列中是否有其他进程在等待，如果有，则唤醒其中一个进程继续执行。

使用示例：

import redis.clients.jedis.Jedis;

public class Main {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("localhost");
        RedisConcurrencyControl control = new RedisConcurrencyControl(jedis);
        try {
            if (control.acquireLock()) {
                if (control.tryEnter()) {
                    // 进程成功进入资源访问队列，执行业务逻辑
                } else {
                    // 进程无法进入资源访问队列，等待其他进程释放锁
                    control.waitEnter();
                }
            } else {
                // 获取锁失败，处理异常情况
           

Redis文档学习地址:  必须点个三连好吧, 步步高升 7. 分布式集合 - 7.1. 映射（Map） - 《Redisson 使用手册》 - 书栈网 · BookStack