Redisson分布式锁实战

使用场景

工作中遇到的场景：在多节点部署的微服务项目中，某一条规则可能正在调度，正在清理，或正在导入。这三种操作都会操作数据库，且没有开启事务。为了保证数据一致性，它们不能同时发生。

所以需要实现多个服务在同一时间对于同一资源的互斥访问。

解决方案

在redis中存储每个规则的状态processStatus，1代表正在调度，2代表正在清理，3代表正在导入。

每次在调度，清理，导入之前，从redis中获取processStatus。

如果有值，说明正在操作，直接根据processStatus的值返回给用户相应提示。

如果没有值，说明该规则处于空闲状态。

        1. 为该规则的processStatus设置对应的值（这个操作在高并发的时候不安全，需要分布式锁）

        2. 开始进行相应操作

        3. 操作结束的finally代码块中，删除redis中processStatus这个key

代码实现

使用redission提供的分布式锁，因为它内置了锁对象自动续期，自旋等待，防止死锁等机制

@Slf4j
    public class RedisDistributedLockUtil {

        private RedissonClient redissonClient = SpringContextHolder.getBean(RedissonClient.class);
        private String lockKey;
        private String status; // 存放处理标记数据
        private boolean locked = false; // 记录是否上锁成功

        public RedisDistributedLockUtil(String key, String status) {
            this.lockKey = key;
            this.status = status;
        }

        public void setAndCheckFlagWithLock() {
            RBucket<Object> bucket = redissonClient.getBucket("quality:" + lockKey + ":isProcessing");
            // first check
            checkBucket(bucket);
            RLock rLock = redissonClient.getLock("quality:" + lockKey + ":lock");
            try {
                rLock.lock();
                // double check
                checkBucket(bucket);
                bucket.set(status, 300000L, TimeUnit.MILLISECONDS);
                locked = true;
                log.info("{}添加redis导入标志位", lockKey);
            } finally {
                rLock.unlock();
            }
        }

        private static void checkBucket(RBucket<Object> bucket) {
            if (CollectionUtils.isNotEmpty(bucket.get())) {
                String str = String.format("该笔规则正在%s，请稍后重试。", RuleProcessingState.getDescByCode(String.valueOf(bucket.get())));
                throw new ServiceException(1, str);
            }
        }

        public void deleteFlag() {
            if (!locked) {
                return;
            }

            try {
                RBucket<Object> bucket = redissonClient.getBucket("quality:" + lockKey + ":isProcessing");
                bucket.delete();
                log.info("删除redis导入标志位 {}", lockKey);
            } catch (Exception e) {
                e.printStackTrace();
                log.error("清理redis标志位失败! {} [{}]", lockKey, e.getMessage());
                throw new ServiceException(1, e.getMessage());
            }
        }
    }

在相应操作的时候使用分布式锁，以Excel导入为例

@Override
public void doAfterAllAnalysed(AnalysisContext analysisContext) {
    try {
        if (CollectionUtils.isEmpty(processDetailEntities) &&
            CollectionUtils.isEmpty(processEntities) &&
            CollectionUtils.isEmpty(resultEntities)) {
            redisDistributedLockUtil.deleteFlag();  // 确保直接return时锁被释放
            return;
        }

        if (CollectionUtils.isNotEmpty(errMsg)) {
            redisDistributedLockUtil.deleteFlag();  // 确保直接return时锁被释放
            return;
        }

        checkOrgCode(); // 检验获取机构代码信息
        if (CollectionUtils.isNotEmpty(errMsg)) {
            redisDistributedLockUtil.deleteFlag();  // 确保直接return时锁被释放
            return;
        }

        orgCode2rowIndex.clear();

        // 提交异步任务，负责执行导入和释放锁
        globalThreadPool.submit(() -> {
            try {
                // 初始化日志
                logUtil.initLog(ruleEntity);

                // 执行导入操作
                startImport();
            } catch (Exception e) {
                log.error("{} 初始化或导入过程中出错：{}", ruleCode, e.getMessage());
                e.printStackTrace();
                errMsg.add(String.format("操作失败！请检查：%s", e.getMessage()));
            } finally {
                // 确保异步线程结束时释放锁
                redisDistributedLockUtil.deleteFlag();
            }
        });

    } catch (Exception e) {
        log.error("主线程执行过程中发生异常：{}", e.getMessage());
        errMsg.add(String.format("操作失败！请检查：%s", e.getMessage()));
        redisDistributedLockUtil.deleteFlag();  // 确保异常时释放锁
    }
}