需求并发修改保证一致性

H愚公移山H

已于 2025-08-06 16:57:15 修改

阅读量231

点赞数 3

CC 4.0 BY-SA版权

文章标签： elasticsearch

于 2025-08-06 16:56:59 首次发布

本文链接：https://blog.csdn.net/HAN_789/article/details/149975594

我们整合Seata分布式事务和双重锁机制（分布式锁+乐观锁）来实现高并发场景下的数据一致性保障。总体思路：

1. 使用Redisson分布式锁（第一重锁）确保同一时间只有一个线程能进入关键业务区域。

2. 在分布式锁保护下，使用乐观锁（第二重锁，基于版本号）进行数据版本校验。

3. 通过Seata管理分布式事务，确保跨服务操作的原子性。

4. 使用RocketMQ事务消息确保最终一致性（如更新ES等操作）。

步骤：

a. 客户端发起更新请求，携带当前版本号。

b. 服务端获取分布式锁（如果获取失败，则返回请求重试或错误）。

c. 在锁内，从数据库加载当前数据，校验客户端版本号与当前版本号是否一致。

d. 若不一致，释放锁并返回冲突错误（包含当前最新数据）。

e. 若一致，执行业务更新，并更新版本号（version+1）。

f. 发送RocketMQ事务消息（用于异步更新其他数据，如ES）。

g. 提交Seata全局事务（如果涉及多个服务，Seata会协调这些服务的事务）。

h. 释放分布式锁。

下面给出详细代码实现：

Java实现代码

1. 双重锁服务实现
@Service
public class DoubleLockService {
    private final RedissonClient redissonClient;
    private final ThreadLocal<Long> lockHoldTime = new ThreadLocal<>();

    @Autowired
    public DoubleLockService(RedissonClient redissonClient) {
        this.redissonClient = redissonClient;
    }

    /**
     * 执行双重锁保护的操作
     * @param lockKey 分布式锁键
     * @param versionSupplier 获取当前版本信息的函数
     * @param businessLogic 业务逻辑
     * @param <T> 返回类型
     */
    public <T> T executeWithDoubleLock(String lockKey, 
                                     Supplier<VersionInfo> versionSupplier,
                                     Supplier<T> businessLogic) {
        RLock lock = redissonClient.getLock(lockKey);
        long startTime = System.currentTimeMillis();
        
        try {
            // 尝试获取分布式锁（带超时控制）
            if (lock.tryLock(2, 15, TimeUnit.SECONDS)) {
                lockHoldTime.set(System.currentTimeMillis() - startTime);
                
                // 获取当前版本信息
                VersionInfo versionInfo = versionSupplier.get();
                
                // 第一重校验：乐观锁版本检查
                if (!versionInfo.isValid()) {
                    throw new OptimisticLockException("版本校验失败", versionInfo.getCurrentData());
                }
                
                // 第二重校验：分布式锁保护下的业务逻辑
                return businessLogic.get();
            }
            throw new ConcurrentModificationException("系统繁忙，请稍后重试");
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new LockAcquisitionException("锁获取中断", e);
        } finally {
            if (lock.isHeldByCurrentThread()) {
                long holdDuration = System.currentTimeMillis() - (startTime + lockHoldTime.get());
                monitor.recordLockDuration(lockKey, holdDuration);
                lock.unlock();
            }
            lockHoldTime.remove();
        }
    }

    // 版本信息封装
    @Data
    @AllArgsConstructor
    public static class VersionInfo {
        private boolean valid;         // 校验是否通过
        private Object currentData;    // 当前最新数据
        private String entityVersion;  // 当前版本号
    }
}

2. 业务服务整合Seata与双重锁

@Service
public class RequirementService {
    private static final Logger logger = LoggerFactory.getLogger(RequirementService.class);
    
    @Autowired
    private DoubleLockService doubleLockService;
    
    @Autowired
    private RequirementRepository requirementRepo;
    
    @Autowired
    private RocketMQTemplate rocketMQTemplate;
    
    @Autowired
    private AuditService auditService;
    
    // Seata全局事务注解
    @GlobalTransactional(timeoutMills = 60000, name = "req-update-tx")
    public Requirement updateRequirement(RequirementUpdateDTO dto) {
        final Long reqId = dto.getId();
        final String clientVersion = dto.getClientVersion();
        
        return doubleLockService.executeWithDoubleLock(
            "REQ_LOCK:" + reqId,
            
            // 版本信息获取函数（在分布式锁保护下执行）
            () -> {
                Requirement current = requirementRepo.findByIdWithLock(reqId);
                if (current == null) {
                    throw new EntityNotFoundException("需求不存在");
                }
                
                boolean valid = current.getVersion().equals(clientVersion);
                return new DoubleLockService.VersionInfo(
                    valid,
                    valid ? null : current,
                    current.getVersion()
                );
            },
            
            // 业务逻辑（双重锁校验通过后执行）
            () -> {
                // 再次确认版本（极端情况保护）
                Requirement entity = requirementRepo.findById(reqId).orElseThrow();
                if (!entity.getVersion().equals(clientVersion)) {
                    throw new OptimisticLockException("并发冲突检测", entity);
                }
                
                // 更新业务字段
                entity.setTitle(dto.getTitle());
                entity.setAttributes(dto.getAttributes());
                entity.setVersion(UUID.randomUUID().toString()); // 生成新版本号
                
                // 保存到数据库
                Requirement saved = requirementRepo.save(entity);
                
                // 发送事务消息
                sendTransactionMessage(saved);
                
                // 记录审计日志
                auditService.logUpdate(saved.getId(), "UPDATE", dto.getOperator());
                
                return saved;
            }
        );
    }
    
    private void sendTransactionMessage(Requirement requirement) {
        RequirementEvent event = new RequirementEvent(
            requirement.getId(),
            requirement.getVersion(),
            requirement.getAttributes()
        );
        
        Message<RequirementEvent> message = MessageBuilder.withPayload(event)
            .setHeader("TRANSACTION_ID", requirement.getId())
            .build();
        
        rocketMQTemplate.sendMessageInTransaction(
            "REQ_UPDATE_GROUP",
            "REQ_UPDATE_TOPIC",
            message,
            requirement.getId()
        );
    }
    
    // RocketMQ事务监听器
    @RocketMQTransactionListener(txProducerGroup = "REQ_UPDATE_GROUP")
    public class TransactionListenerImpl implements RocketMQLocalTransactionListener {
        
        @Override
        public RocketMQLocalTransactionState executeLocalTransaction(Message msg, Object arg) {
            Long reqId = (Long) arg;
            try {
                // 本地事务：更新状态为处理中
                auditService.updateTxStatus(reqId, "PROCESSING");
                return RocketMQLocalTransactionState.COMMIT;
            } catch (Exception e) {
                logger.error("本地事务执行失败", e);
                return RocketMQLocalTransactionState.ROLLBACK;
            }
        }
        
        @Override
        public RocketMQLocalTransactionState checkLocalTransaction(Message msg) {
            Long reqId = (Long) msg.getHeaders().get("TRANSACTION_ID");
            String status = auditService.getTxStatus(reqId);
            
            if ("PROCESSING".equals(status)) {
                return RocketMQLocalTransactionState.UNKNOWN;
            }
            return "COMPLETED".equals(status) ? 
                RocketMQLocalTransactionState.COMMIT : 
                RocketMQLocalTransactionState.ROLLBACK;
        }
    }
}

3. ES同步服务（最终一致性）

@Service
@RocketMQMessageListener(
    topic = "REQ_UPDATE_TOPIC",
    consumerGroup = "ES_SYNC_GROUP",
    selectorExpression = "*",
    consumeMode = ConsumeMode.ORDERLY
)
public class ESSyncConsumer implements RocketMQListener<RequirementEvent> {
    
    @Autowired
    private ElasticsearchRestTemplate elasticsearchTemplate;
    
    @Autowired
    private EventLogService eventLogService;
    
    @Override
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void onMessage(RequirementEvent event) {
        // 幂等检查
        if (eventLogService.isProcessed(event.getMessageId())) {
            return;
        }
        
        try {
            // 转换并保存到ES
            RequirementDoc doc = convertToDoc(event);
            elasticsearchTemplate.save(doc);
            
            // 更新处理状态
            eventLogService.markProcessed(event.getMessageId(), "SUCCESS");
            
            // 发布领域事件
            applicationContext.publishEvent(new RequirementUpdatedEvent(this, event));
        } catch (Exception e) {
            eventLogService.markFailed(event.getMessageId(), e.getMessage());
            throw new RuntimeException("ES同步失败", e);
        }
    }
    
    private RequirementDoc convertToDoc(RequirementEvent event) {
        RequirementDoc doc = new RequirementDoc();
        doc.setId(event.getReqId().toString());
        doc.setEntityId(event.getReqId());
        doc.setVersion(event.getVersion());
        // 设置其他属性...
        return doc;
    }
}

4. 冲突处理与监控

@RestControllerAdvice
public class ConsistencyExceptionHandler {
    
    private static final MeterRegistry meterRegistry = Metrics.globalRegistry;
    
    // 乐观锁冲突处理
    @ExceptionHandler(OptimisticLockException.class)
    public ResponseEntity<ConflictResponse> handleOptimisticLockConflict(
            OptimisticLockException ex) {
        
        // 监控指标
        meterRegistry.counter("consistency.conflict.optimistic").increment();
        
        Object currentData = null;
        if (ex.getCause() instanceof DoubleLockService.VersionInfo) {
            DoubleLockService.VersionInfo versionInfo = 
                (DoubleLockService.VersionInfo) ex.getCause();
            currentData = versionInfo.getCurrentData();
        }
        
        return ResponseEntity.status(HttpStatus.CONFLICT)
            .body(new ConflictResponse(
                "VERSION_MISMATCH", 
                "数据已被修改，请刷新后重试",
                currentData
            ));
    }
    
    // 分布式锁冲突处理
    @ExceptionHandler(ConcurrentModificationException.class)
    public ResponseEntity<ApiResponse> handleDistributedLockConflict() {
        meterRegistry.counter("consistency.conflict.distributed").increment();
        return ResponseEntity.status(HttpStatus.TOO_MANY_REQUESTS)
            .header("Retry-After", "2000")
            .body(ApiResponse.error("LOCK_CONFLICT", "系统繁忙，请稍后重试"));
    }
    
    // 事务失败处理
    @ExceptionHandler(SeataException.class)
    public ResponseEntity<ApiResponse> handleSeataException(SeataException ex) {
        meterRegistry.counter("consistency.error.transaction").increment();
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
            .body(ApiResponse.error("TX_FAILURE", "事务处理失败，请重试"));
    }
}

完整流程总结（500字）

在需求管理系统的高并发场景下，数据一致性保障体系通过以下流程运作：

客户端请求：用户提交需求更新请求，携带当前版本号(clientVersion)
双重锁校验：
- 分布式锁(第一重)：使用Redisson获取需求ID对应的分布式锁，防止并行操作
- 乐观锁(第二重)：在锁内加载当前数据，校验客户端版本与数据库版本一致性
事务处理：
- 版本校验通过后，在Seata全局事务保护下执行业务更新
- 生成新版本号(UUID)并更新数据库
- 记录审计日志标记事务开始
消息发布：通过RocketMQ发送事务消息，包含需求ID和新版本号
事务确认：
- RocketMQ事务监听器执行本地事务，更新事务状态
- 定时检查确认事务状态，提交或回滚消息
数据同步：
- 消费者顺序处理消息，幂等检查后同步到Elasticsearch
- 更新事件状态，发布领域事件
冲突处理：
- 版本不匹配时：返回409冲突及当前数据
- 锁获取失败时：返回429限流，提示重试
- 事务失败时：触发Seata回滚，返回错误信息
监控保障：
- 记录锁持有时间、冲突次数等指标
- 事务状态全程追踪
- 消息消费幂等保障