spring-integration-redis中分布式锁RedisLockRegistry的使用

pom依赖：

<!-- redis -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.integration</groupId>
    <artifactId>spring-integration-redis</artifactId>
</dependency>

配置：

@Configuration
public class RedisLockConfig {
 
    @Bean
    public RedisLockRegistry redisLockRegistry(RedisConnectionFactory redisConnectionFactory) {
         //第一个参数redisConnectionFactory
         //第二个参数registryKey，分布式锁前缀，设置为项目名称会好些
         //该构造方法对应的分布式锁，默认有效期是60秒.可以自定义
         return new RedisLockRegistry(redisConnectionFactory, "boot-launch");
         //return new RedisLockRegistry(redisConnectionFactory, "boot-launch",60);
     }
}

方式1：

    @Autowired
    private RedisLockRegistry redisLockRegistry;
Lock lock = redisLockRegistry.obtain("lockkey-" + 1);
//tryLock尝试获取锁（成功返回true，失败返回false）;
    if (lock.tryLock()) {
        try {
            // 业务代码块
 
        } finally {
        //走到这里说明获取锁一定是成功的
        try{
        lock.unlock();
        }catch (IllegalStateException e){
        //业务操作时间过长，会导致锁超时内系统释放，这里就会产生超时异常
        log.error("释放时发现锁过期");
        }
            
        }
    } else {
    //走到这里说明获取锁一定是失败的的
        log.info("并发抢锁失败");
    }

方式2：

    @Autowired
    private RedisLockRegistry redisLockRegistry;
Lock lock = redisLockRegistry.obtain("lockkey-" + 1);
//lock()一直循环获取锁，循环周期为100毫秒（成功了则无返回，失败了则抛异常），理论上一定能获取到锁，因为会一直循环取锁
    try {
    lock.lock();
        // 业务代码块（这里要判断并发情况下的业务幂等性）
    }catch (CannotAcquireLockException e){
    //当redis挂掉时执行redis操作失败会产生异常CannotAcquireLockException；说明获取锁失败了
    log.error("get redis lock fail");
    } finally {
    //走到这里 获取锁不一定是成功的，异常时也走，因此需要判断lock状态
    if(Objects.nonNull(lock)){
    //锁存在才需要释放
        try{
        lock.unlock();
        }catch (IllegalStateException e){
        //业务操作时间过长，会导致锁超时内系统释放，这里就会产生超时异常
        log.error("释放时发现锁过期");
        }
    }
    }

方式3：

    @Autowired
    private RedisLockRegistry redisLockRegistry;
Lock lock = redisLockRegistry.obtain("lockkey-" + 1);
try {
//tryLock(3, TimeUnit.SECONDS):在3秒钟内循环获取锁，超过3秒还没有获取到就认为获取失败了，这个方法会抛出异常InterruptedException，
        boolean isLocked = lock.tryLock(3, TimeUnit.SECONDS);
        if (isLocked) {
        // 业务代码块
    }
        } catch (InterruptedException e) {
            log.error("get redis lock fail");
        }finally {
        //获取锁失败的时候也会走，需要判断锁失败时不去释放
            if(Objects.nonNull(lock)){
    //锁存在才需要释放
        try{
        lock.unlock();
        }catch (IllegalStateException e){
        //业务操作时间过长，会导致锁超时内系统释放，这里就会产生超时异常
        log.error("释放时发现锁过期");
        }
    }
        }

总结：

解决同一个用户并发操作同一个资源时，如提交时按钮连击、多端调用同一个业务接口：使用方式1；方式2（使用方式2时需要做幂等判断，如连击操作多次调用时，对第二次调用不做处理）

解决并发限流时，如抽奖系统中对商品sku库存做锁操作，防止多个用户同时扣减库存导致库存数量少扣：使用方式2、或者方式3（锁等待时间=预计业务代码执行时间）

三方式都要注意释放锁时做锁过期处理