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 setAndCheckFlagWithRLock() {
        RBucket<Object> bucket = redissonClient.getBucket("quality:" + lockKey + ":isProcessing");
        RLock rLock = redissonClient.getLock("quality:" + lockKey + ":lock");
        try {
            rLock.lock();
            // double check
            if (bucket.get() != null) {
                String str = String.format("该套规则正在处理! 请稍后重试。", RuleProcessingState.getDescByCode(String.valueOf(bucket.get())));
                throw new ServiceException(1, str);
            }
            // 保险起见，设置5min过期时间
            bucket.set(status, 300000L, TimeUnit.MILLISECONDS);
            locked = true;
            log.info("添加redis导入标志位 {}", lockKey);
        } finally {
            rLock.unlock();
        }
    }

    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导入为例

@Slf4j
public class DetailImportListener extends AnalysisEventListener<Map<String, String>> {

    public List<String> errMsg = new ArrayList<>();
    private List<ProcessDetailEntity> processDetailEntities;
    private List<QualityProcessEntity> processEntities;
    private List<Map> resultEntities;
    private RedisDistributedLockUtil redisDistributedLockUtil;

    public DetailImportListener(List<ProcessDetailEntity> processDetailEntities,
                                List<QualityProcessEntity> processEntities,
                                List<Map> resultEntities) {
        this.processDetailEntities = processDetailEntities;
        this.processEntities = processEntities;
        this.resultEntities = resultEntities;
    }

    @Override
    public void invoke(Map<String, String> lineMap, AnalysisContext analysisContext) {
        // 如果错误信息不为空，直接返回
        if (CollectionUtils.isNotEmpty(errMsg)) return;

        try {
            // 获取当前行的索引
            Integer rowIndex = analysisContext.readRowHolder().getRowIndex() + 1;

            // 取得 ruleAttribute，首先根据ruleAttribute查询对应的ruleCode和KeywordsValue
            String ruleAttribute = lineMap.get(2);
            if (rowIndex == 2) {
                ruleEntity = checkRuleDao.selectByRuleAttribute(ruleAttribute);
                if (ObjectUtils.isEmpty(ruleEntity)) {
                    errMsg.add(String.format("第%d行数据出错，查调规则失败！", rowIndex));
                    return;
                }

                ruleCode = ruleEntity.getRuleCode();
                if (StringUtils.isBlank(ruleCode)) {
                    errMsg.add(String.format("第%d行数据出错，查调规则失败！", rowIndex));
                    return;
                }

                // 创建 Redis 分布式锁工具实例并设置标志位
                redisDistributedLockUtil = new RedisDistributedLockUtil(ruleCode, RuleProcessingState.Importing.getCode());
                redisDistributedLockUtil.setAndCheckFlagWithRLock();
            }

            // 处理 problemStatus 字段
            String problemStatus = lineMap.get(0);
            if ("已解决".equals(problemStatus)) {
                return;
            }

            // 处理当前行的数据
            dealLine(lineMap, rowIndex);
        } catch (Exception e) {
            e.printStackTrace();
            errMsg.add(String.format("第%d行解析数据出错，请检查: %s", rowIndex, e.getMessage()));
        }
    }

    @Override
    public void doAfterAllAnalysed(AnalysisContext analysisContext) {
        try {
            // 如果所有集合都为空，则直接返回
            if (CollectionUtils.isEmpty(processDetailEntities) &&
                    CollectionUtils.isEmpty(processEntities) &&
                    CollectionUtils.isEmpty(resultEntities)) {
                return;
            }

            // 如果错误信息不为空，则直接返回
            if (CollectionUtils.isNotEmpty(errMsg)) {
                return;
            }

            // 检测机构编号映射信息
            checkOrgCode();
            if (CollectionUtils.isNotEmpty(errMsg)) {
                return;
            }

            // 清空orgCode2rowIndex
            orgCode2rowIndex.clear();

            // 提交任务到全局线程池处理
            globalThreadPool.submit(() -> {
                try {
                    logUtil.initLog(ruleEntity);
                } catch (Exception e) {
                    log.error("{} 初始化日志表出错: [{}]", ruleCode, e.getMessage());
                    e.printStackTrace();
                    throw new ServiceException(1, e.getMessage());
                }

                startImport();
            });
        } catch (Exception e) {
            errMsg.add(String.format("操作失败! 请检查: %s", e.getMessage()));
        } finally {
            // 一定要在finally中删除标志位，否则会导致功能不可用
            redisDistributedLockUtil.deleteFlag();
        }
    }
}