解决线程并发redisson使用遇到的坑

下面是“解决线程并发redisson使用遇到的坑”的完整攻略。

问题描述

在使用 Redisson 实现分布式锁时，遇到了线程并发问题。多个线程同时获取锁并执行业务逻辑，但是在释放锁之前，会有其他线程获取到锁，进而导致同一份数据被多个线程同时操作，最终导致了数据的不一致性。

解决方案

1. 针对锁失效问题

在 Redisson 中，锁可以设置失效时间和等待时间。当获取锁时，如果锁被其他线程占用，当前线程会等待一段时间再尝试获取锁。而锁失效时间是有限制的，如果锁被占用的时间超过了失效时间，那么锁就会失效，从而导致数据不一致。

解决这个问题的方法是，在获取锁时，可以手动设置失效时间，将锁的失效时间设置为业务逻辑需要的最大时间。

RLock lock = redisson.getLock("lock");
boolean locked = lock.tryLock(2, TimeUnit.SECONDS); //尝试获取锁，等待时间为 2s
if (locked) {
    lock.lock(10, TimeUnit.SECONDS); //锁定 10s
    //执行业务逻辑
    lock.unlock(); //释放锁
}

2. 针对多个线程同时获取锁问题

如果存在多个线程同时获取锁的情况，可以使用 Redisson 的分布式信号量。（Semaphore）

Semaphore 用于控制同时访问某个资源的线程个数，可以通过 acquire() 和 release() 方法获取和释放许可证。

RSemaphore semaphore = redisson.getSemaphore("semaphore");
try {
    semaphore.acquire(); //获取许可证
    //执行业务逻辑
} finally {
    semaphore.release(); //释放许可证
}

通过使用信号量，可以控制同时访问某个共享资源的线程数，避免多个线程同时访问同一个共享资源，导致数据不一致或业务逻辑出错。

示例说明

示例一

//定义 RedissonClient
Config config = new Config();
config.useSingleServer().setAddress("redis://127.0.0.1:6379").setPassword("password");
RedissonClient redisson = Redisson.create(config);

//定义锁
RLock lock = redisson.getLock("lock");

//同时开启 10 个线程获取锁
for (int i = 0; i < 10; i++) {
    new Thread(() -> {
        boolean locked = false;
        try {
            locked = lock.tryLock(2, TimeUnit.SECONDS); //等待 2s 尝试获取锁
            if (locked) {
                //模拟业务逻辑
                Thread.sleep(1000);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            if (locked) {
                lock.unlock();
            }
        }
    }).start();
}

上述代码中，我们开启了 10 个线程来获取锁，并且在获取锁的时候都添加了等待时间。经过测试，如果不做任何修改，使用 Redisson 的默认锁实现，有可能会导致锁失效，从而导致数据不一致。

解决方法就是在获取锁时，手动设置失效时间，将锁的失效时间设置为业务逻辑需要的最大时间。

//解决锁失效问题
Config config = new Config();
config.useSingleServer().setAddress("redis://127.0.0.1:6379").setPassword("password");
RedissonClient redisson = Redisson.create(config);

RLock lock = redisson.getLock("lock");
for (int i = 0; i < 10; i++) {
    new Thread(() -> {
        boolean locked = false;
        try {
            locked = lock.tryLock(2, TimeUnit.SECONDS);
            if (locked) {
                lock.lock(10, TimeUnit.SECONDS); //锁定 10s
                //模拟业务逻辑
                Thread.sleep(1000);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            if (locked) {
                lock.unlock();
            }
        }
    }).start();
}

上述代码中，我们手动将锁的失效时间设置为 10 秒，避免了锁失效问题。同时为了更好的演示，我们将业务逻辑的执行时间设置为 1 秒。

示例二

//定义 RedissonClient
Config config = new Config();
config.useSingleServer().setAddress("redis://127.0.0.1:6379").setPassword("password");
RedissonClient redisson = Redisson.create(config);

//定义信号量
RSemaphore semaphore = redisson.getSemaphore("semaphore");

//同时开启 20 个线程获取锁
for (int i = 0; i < 20; i++) {
    new Thread(() -> {
        try {
            semaphore.acquire(); //获取许可证
            //模拟业务逻辑
            Thread.sleep(1000);
            semaphore.release(); //释放许可证
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }).start();
}

上述代码中，我们开启了 20 个线程来获取信号量，其中信号量的计数器初始值为 1，因此只有 1 个线程可以同时进入业务逻辑代码，并且要在执行完业务逻辑之后才能释放许可证，让其他线程进入。

解决多个线程同时获取锁问题的方法就是使用分布式信号量来限制线程数。

//解决线程并发问题
Config config = new Config();
config.useSingleServer().setAddress("redis://127.0.0.1:6379").setPassword("password");
RedissonClient redisson = Redisson.create(config);

RSemaphore semaphore = redisson.getSemaphore("semaphore");
semaphore.trySetPermits(1); //设置信号量为 1

for (int i = 0; i < 20; i++) {
    new Thread(() -> {
        try {
            semaphore.acquire(); //获取许可证
            //模拟业务逻辑
            Thread.sleep(1000);
            semaphore.release(); //释放许可证
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }).start();
}

上述代码中，我们将信号量的计数器初始值设置为 1，避免多个线程同时获取信号量。经过测试，使用分布式信号量后，确实可以避免多个线程同时获取共享资源的问题。