一文搞懂机器学习入门知识！
2026/1/10 3:48:34
一、问题定义与核心概念
1.1 问题定义
悬挂问题（Hanging）
text
复制
下载
正常流程：Try → Confirm/Cancel 悬挂场景：Try执行成功 → 网络超时 → 事务管理器调用Cancel → Cancel未执行 结果：预留的资源无法释放，形成悬挂事务
空回滚问题（Empty Rollback）
text
复制
下载
正常流程：Try失败 → 调用Cancel 空回滚场景：Try未执行（网络超时） → 事务管理器超时触发Cancel → Cancel无Try记录可回滚 结果：执行了无效的Cancel操作
二、悬挂问题解决方案
2.1 状态标记法
java
复制
下载
@Component public class HangPreventionService { @Autowired private TransactionStateStore stateStore; /** * Try阶段：记录事务状态 */ @Transactional public void tryPhase(String xid, String businessId) { // 1. 检查是否存在未完成的同一业务事务 TransactionState existing = stateStore.getUnfinishedByBusinessId(businessId); if (existing != null && !isExpired(existing)) { throw new TransactionHangingException("存在未完成事务，请稍后重试"); } // 2. 插入事务记录 TransactionState state = new TransactionState(); state.setXid(xid); state.setBusinessId(businessId); state.setStatus(TransactionStatus.TRYING); state.setCreateTime(new Date()); state.setExpireTime(DateUtils.addMinutes(new Date(), 30)); stateStore.save(state); // 3. 执行业务Try逻辑 businessService.tryOperation(businessId); } /** * Cancel阶段：检查并处理悬挂 */ @Transactional public void cancelPhase(String xid) { // 1. 查询事务状态 TransactionState state = stateStore.getByXid(xid); if (state == null) { // 未找到记录，可能是空回滚或数据不一致 log.warn("未找到事务记录，可能已超时清理: xid={}", xid); return; } // 2. 状态验证 if (state.getStatus() == TransactionStatus.CANCELLED) { log.info("事务已取消，幂等返回: xid={}", xid); return; } if (state.getStatus() != TransactionStatus.TRYING) { throw new IllegalStateException("事务状态异常，无法取消"); } // 3. 检查是否悬挂（Try完成但未收到Confirm） if (isHanging(state)) { log.warn("检测到悬挂事务，执行补偿: xid={}", xid); compensateHanging(state); } else { // 4. 正常取消 businessService.cancelOperation(state.getBusinessId()); } // 5. 更新状态 state.setStatus(TransactionStatus.CANCELLED); state.setUpdateTime(new Date()); stateStore.update(state); } }2.2 防悬挂锁机制
java
复制
下载
public class HangPreventionLock { private final RedissonClient redisson; private final long lockTimeout = 30; // 锁超时时间（秒） /** * 获取防悬挂锁 */ public boolean acquireHangLock(String xid, String businessId) { String lockKey = String.format("tcc:hanging:lock:%s:%s", xid, businessId); RLock lock = redisson.getLock(lockKey); try { // 尝试获取锁，最多等待5秒 return lock.tryLock(5, lockTimeout, TimeUnit.SECONDS); } catch (InterruptedException e) { Thread.currentThread().interrupt(); return false; } } /** * Try前置检查 */ public boolean preCheckTry(String xid, String businessId) { // 1. 检查是否正在取消中 String cancelingKey = String.format("tcc:canceling:%s", xid); if (redisson.getBucket(cancelingKey).get() != null) { throw new TransactionCancellingException("事务正在取消中"); } // 2. 获取防悬挂锁 if (!acquireHangLock(xid, businessId)) { throw new TransactionLockException("获取防悬挂锁失败"); } return true; } }篇幅限制下面就只能给大家展示小册部分内容了。整理了一份核心面试笔记包括了：Java面试、Spring、JVM、MyBatis、Redis、MySQL、并发编程、微服务、Linux、Springboot、SpringCloud、MQ、Kafc
需要全套面试笔记及答案
【点击此处即可/免费获取】
2.3 定时清理悬挂事务
java
复制
下载
@Component public class HangTransactionCleaner { @Autowired private TransactionStateStore stateStore; @Autowired private Compensator compensator; /** * 定时清理悬挂事务（每分钟执行一次） */ @Scheduled(fixedDelay = 60000) public void cleanHangingTransactions() { // 1. 查询超时未完成的事务 List<TransactionState> hangingTransactions = stateStore.findHangingTransactions(5); // 超过5分钟 // 2. 批量处理 hangingTransactions.forEach(this::processHangingTransaction); } private void processHangingTransaction(TransactionState transaction) { try { log.info("开始处理悬挂事务: xid={}, status={}", transaction.getXid(), transaction.getStatus()); switch (transaction.getStatus()) { case TRYING: // Try成功但未收到Confirm/Cancel handleHangingTry(transaction); break; case CONFIRMING: // Confirm执行中卡住 handleHangingConfirm(transaction); break; case CANCELLING: // Cancel执行中卡住 handleHangingCancel(transaction); break; } // 3. 标记为已处理 transaction.setStatus(TransactionStatus.COMPENSATED); transaction.setUpdateTime(new Date()); stateStore.update(transaction); } catch (Exception e) { log.error("处理悬挂事务失败: xid={}", transaction.getXid(), e); // 发送告警，需要人工干预 alertService.sendAlert("悬挂事务处理失败", transaction); } } }三、空回滚问题解决方案
3.1 Try状态检查法
java
复制
下载
@Component public class EmptyRollbackPreventer { @Autowired private TransactionLogService logService; /** * Cancel接口实现（防空回滚） */ @Transactional public void cancelWithCheck(String xid, String businessId) { // 1. 查询Try执行记录 TryRecord tryRecord = logService.getTryRecord(xid); if (tryRecord == null) { // 2. Try未执行，属于空回滚 logEmptyRollback(xid, businessId); // 3. 插入空回滚记录，防止重复处理 logService.saveEmptyRollbackRecord(xid, businessId); // 4. 直接返回成功，保证幂等性 return; } // 5. 幂等检查：是否已取消过 if (tryRecord.getStatus() == TryStatus.CANCELLED) { log.info("Cancel已执行过，幂等返回: xid={}", xid); return; } // 6. 验证状态：必须TRY_SUCCESS才能Cancel if (tryRecord.getStatus() != TryStatus.TRY_SUCCESS) { throw new IllegalStateException( String.format("事务状态[%s]不允许Cancel", tryRecord.getStatus()) ); } // 7. 执行实际的Cancel逻辑 executeCancel(businessId); // 8. 更新状态 tryRecord.setStatus(TryStatus.CANCELLED); logService.updateTryRecord(tryRecord); } /** * Try接口：必须记录状态 */ @Transactional public void tryWithRecord(String xid, String businessId) { // 1. 插入Try记录（初始状态） TryRecord record = new TryRecord(); record.setXid(xid); record.setBusinessId(businessId); record.setStatus(TryStatus.TRYING); record.setCreateTime(new Date()); logService.saveTryRecord(record); try { // 2. 执行业务Try操作 businessService.doTry(businessId); // 3. 更新为成功状态 record.setStatus(TryStatus.TRY_SUCCESS); logService.updateTryRecord(record); } catch (Exception e) { // 4. 更新为失败状态 record.setStatus(TryStatus.TRY_FAILED); record.setErrorMsg(e.getMessage()); logService.updateTryRecord(record); throw e; } } }3.2 预写日志方案
java
复制
下载
public class PreWriteLogSolution { private final TransactionLogDAO logDAO; /** * 两阶段防空回滚方案 */ public void processTransaction(String xid, String businessId) { // 第一阶段：预写日志 preWriteTransactionLog(xid, businessId); try { // 第二阶段：执行业务 executeBusiness(xid, businessId); // 第三阶段：确认日志 confirmTransactionLog(xid); } catch (Exception e) { // 第四阶段：回滚检查 rollbackWithCheck(xid, businessId, e); } } private void preWriteTransactionLog(String xid, String businessId) { TransactionLog log = new TransactionLog(); log.setXid(xid); log.setBusinessId(businessId); log.setStatus(TransactionLogStatus.PREPARED); log.setCreateTime(System.currentTimeMillis()); log.setExpireTime(System.currentTimeMillis() + 300000); // 5分钟过期 // 插入预写日志 if (logDAO.insert(log) <= 0) { throw new TransactionException("预写事务日志失败"); } } private void rollbackWithCheck(String xid, String businessId, Exception cause) { // 1. 检查预写日志是否存在 TransactionLog preLog = logDAO.selectByXid(xid); if (preLog == null || preLog.getStatus() != TransactionLogStatus.PREPARED) { // 没有预写日志，属于空回滚或重复回滚 logEmptyRollback(xid, businessId, cause); // 插入空回滚记录 logDAO.insertEmptyRollback(xid, businessId, cause.getMessage()); return; } // 2. 执行实际的回滚逻辑 try { businessService.cancel(businessId); // 3. 更新日志状态 preLog.setStatus(TransactionLogStatus.ROLLBACKED); preLog.setUpdateTime(System.currentTimeMillis()); logDAO.update(preLog); } catch (Exception e) { log.error("回滚业务失败", e); // 标记为回滚失败，需要补偿 preLog.setStatus(TransactionLogStatus.ROLLBACK_FAILED); logDAO.update(preLog); throw e; } } }四、综合解决方案
4.1 完整TCC事务管理器
java
复制
下载
@Slf4j @Component public class EnhancedTccTransactionManager { @Autowired private TransactionStateService stateService; @Autowired private BusinessExecutor businessExecutor; @Autowired private HangPreventionLock hangLock; /** * 增强版Try阶段 */ public void enhancedTry(String xid, String businessId, TryAction tryAction) { // 1. 防悬挂检查 checkHangingRisk(businessId); // 2. 获取分布式锁 boolean locked = hangLock.acquireHangLock(xid, businessId); if (!locked) { throw new TransactionException("获取事务锁失败"); } try { // 3. 记录开始状态 stateService.recordTryStart(xid, businessId); // 4. 执行业务Try tryAction.execute(); // 5. 记录Try成功 stateService.recordTrySuccess(xid); } catch (Exception e) { // 6. 记录Try失败 stateService.recordTryFailure(xid, e.getMessage()); throw e; } finally { // 7. 释放锁（设置较短过期时间，Confirm/Cancel会重新获取） hangLock.releaseLockWithDelay(xid, businessId, 10); } } /** * 增强版Cancel阶段 */ public void enhancedCancel(String xid, String businessId, CancelAction cancelAction) { // 1. 获取Cancel锁（防止并发Cancel） boolean cancelLocked = hangLock.acquireCancelLock(xid); try { // 2. 检查是否为空回滚 TransactionState state = stateService.getState(xid); if (state == null || state.getStatus() == TransactionStatus.INIT) { // 空回滚处理 handleEmptyRollback(xid, businessId); return; } // 3. 幂等检查 if (state.getStatus() == TransactionStatus.CANCELLED || state.getStatus() == TransactionStatus.CANCELLED_EMPTY) { log.info("Cancel已执行，幂等返回: xid={}", xid); return; } // 4. 状态验证 if (state.getStatus() != TransactionStatus.TRY_SUCCESS) { throw new IllegalStateException( String.format("事务状态[%s]不允许Cancel", state.getStatus()) ); } // 5. 执行业务Cancel cancelAction.execute(); // 6. 更新状态 stateService.markAsCancelled(xid); } finally { if (cancelLocked) { hangLock.releaseCancelLock(xid); } } } /** * 防悬挂风险检查 */ private void checkHangingRisk(String businessId) { List<TransactionState> unfinished = stateService.getUnfinishedByBusinessId(businessId, 10); // 最近10分钟 if (!unfinished.isEmpty()) { throw new TransactionHangingRiskException( String.format("业务[%s]存在未完成事务", businessId) ); } } /** * 空回滚处理 */ private void handleEmptyRollback(String xid, String businessId) { log.warn("检测到空回滚: xid={}, businessId={}", xid, businessId); // 1. 记录空回滚日志 stateService.recordEmptyRollback(xid, businessId); // 2. 监控上报 monitorService.reportEmptyRollback(xid, businessId); // 3. 返回成功（保证幂等性） } }4.2 状态机设计
java
复制
下载
public enum TransactionStatus { // 初始状态 INIT("初始状态"), // Try阶段状态 TRYING("Try执行中"), TRY_SUCCESS("Try执行成功"), TRY_FAILED("Try执行失败"), // Confirm阶段状态 CONFIRMING("Confirm执行中"), CONFIRMED("Confirm执行成功"), CONFIRM_FAILED("Confirm执行失败"), // Cancel阶段状态 CANCELLING("Cancel执行中"), CANCELLED("Cancel执行成功"), CANCELLED_EMPTY("空回滚"), CANCEL_FAILED("Cancel执行失败"), // 悬挂处理状态 HANGING_DETECTED("检测到悬挂"), COMPENSATING("补偿中"), COMPENSATED("已补偿"), COMPENSATE_FAILED("补偿失败"); private final String description; TransactionStatus(String description) { this.description = description; } // 状态转移检查 public boolean canTransferTo(TransactionStatus target) { // 定义合法的状态转移规则 Map<TransactionStatus, Set<TransactionStatus>> transferRules = new HashMap<>(); transferRules.put(INIT, Set.of(TRYING)); transferRules.put(TRYING, Set.of(TRY_SUCCESS, TRY_FAILED, HANGING_DETECTED)); transferRules.put(TRY_SUCCESS, Set.of(CONFIRMING, CANCELLING, HANGING_DETECTED)); transferRules.put(TRY_FAILED, Set.of(CANCELLING)); // ... 其他转移规则 Set<TransactionStatus> allowedTargets = transferRules.get(this); return allowedTargets != null && allowedTargets.contains(target); } }五、数据库表设计
5.1 事务状态表
sql
复制
下载
CREATE TABLE tcc_transaction_state ( id BIGINT PRIMARY KEY AUTO_INCREMENT COMMENT '主键', xid VARCHAR(64) NOT NULL COMMENT '全局事务ID', business_id VARCHAR(64) NOT NULL COMMENT '业务ID', business_type VARCHAR(32) NOT NULL COMMENT '业务类型', -- 状态信息 status VARCHAR(32) NOT NULL COMMENT '事务状态', retry_count INT DEFAULT 0 COMMENT '重试次数', max_retry INT DEFAULT 3 COMMENT '最大重试次数', error_msg TEXT COMMENT '错误信息', -- 时间信息 create_time DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间', update_time DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间', expire_time DATETIME NOT NULL COMMENT '过期时间', finish_time DATETIME COMMENT '完成时间', -- 控制字段 version INT DEFAULT 1 COMMENT '版本号（乐观锁）', is_deleted TINYINT DEFAULT 0 COMMENT '是否删除', -- 索引 UNIQUE KEY uk_xid (xid), KEY idx_business_id (business_id), KEY idx_status_expire (status, expire_time), KEY idx_create_time (create_time) ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='TCC事务状态表';
5.2 防悬挂锁表
sql
复制
下载
CREATE TABLE tcc_hang_lock ( id BIGINT PRIMARY KEY AUTO_INCREMENT, lock_key VARCHAR(128) NOT NULL COMMENT '锁Key', lock_value VARCHAR(64) NOT NULL COMMENT '锁值', lock_holder VARCHAR(64) NOT NULL COMMENT '锁持有者', expire_time DATETIME NOT NULL COMMENT '锁过期时间', create_time DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP, UNIQUE KEY uk_lock_key (lock_key), KEY idx_expire_time (expire_time) ) COMMENT='防悬挂锁表';
5.3 空回滚记录表
sql
复制
下载
CREATE TABLE tcc_empty_rollback_log ( id BIGINT PRIMARY KEY AUTO_INCREMENT, xid VARCHAR(64) NOT NULL COMMENT '事务ID', business_id VARCHAR(64) NOT NULL COMMENT '业务ID', reason VARCHAR(256) COMMENT '空回滚原因', create_time DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP, UNIQUE KEY uk_xid_business (xid, business_id), KEY idx_create_time (create_time) ) COMMENT='空回滚记录表';
篇幅限制下面就只能给大家展示小册部分内容了。整理了一份核心面试笔记包括了：Java面试、Spring、JVM、MyBatis、Redis、MySQL、并发编程、微服务、Linux、Springboot、SpringCloud、MQ、Kafc
需要全套面试笔记及答案
【点击此处即可/免费获取】
六、监控与告警
6.1 监控指标
java
复制
下载
@Component public class TccMonitor { // 悬挂事务监控 @Meter("tcc.hanging.count") private Meter hangingCount; // 空回滚监控 @Meter("tcc.empty_rollback.count") private Meter emptyRollbackCount; // 事务成功率监控 @Timer("tcc.transaction.duration") private Timer transactionDuration; // 记录悬挂事务 public void recordHanging(String xid, String businessId) { hangingCount.increment(); // 记录详细日志 log.warn("检测到悬挂事务: xid={}, businessId={}", xid, businessId); // 发送监控事件 eventPublisher.publishEvent(new HangingTransactionEvent(xid, businessId)); } // 记录空回滚 public void recordEmptyRollback(String xid, String businessId) { emptyRollbackCount.increment(); log.info("记录空回滚: xid={}, businessId={}", xid, businessId); // 上报到监控系统 monitorClient.reportEmptyRollback(xid, businessId); } }6.2 告警规则配置
yaml
复制
下载
# alert-rules.yml tcc_monitoring: rules: # 悬挂事务告警 - alert: HangingTransactionDetected expr: | increase(tcc_hanging_count_total[5m]) > 10 for: 2m labels: severity: warning annotations: summary: "检测到悬挂事务" description: "5分钟内新增悬挂事务 {{ $value }} 个" # 空回滚率过高告警 - alert: HighEmptyRollbackRate expr: | rate(tcc_empty_rollback_count_total[10m]) / rate(tcc_transaction_total[10m]) > 0.01 for: 5m labels: severity: warning annotations: summary: "空回滚率过高" description: "空回滚率达到 {{ $value | humanizePercentage }}" # 事务成功率下降告警 - alert: TransactionSuccessRateDrop expr: | (rate(tcc_success_count_total[10m]) / rate(tcc_transaction_total[10m])) < 0.95 for: 3m labels: severity: critical annotations: summary: "事务成功率下降" description: "事务成功率下降至 {{ $value | humanizePercentage }}"七、最佳实践总结
7.1 悬挂问题防护要点
text
复制
下载
✅ Try前检查：检查同一业务是否存在未完成事务 ✅ 资源锁：使用分布式锁控制并发 ✅ 超时清理：定时任务清理超时事务 ✅ 状态验证：Cancel前验证事务状态
7.2 空回滚问题防护要点
text
复制
下载
✅ Try记录：必须记录Try执行状态 ✅ Cancel检查：Cancel前检查Try是否执行 ✅ 幂等设计：Cancel操作必须幂等 ✅ 空回滚日志：记录空回滚用于分析
7.3 实施建议
java
复制
下载
// 分阶段实施路线图 public class TccSolutionRoadmap { // Phase 1: 基础防护（1-2周） // - 实现Try状态记录 // - Cancel幂等性保证 // - 基本状态检查 // Phase 2: 悬挂防护（2-3周） // - 引入防悬挂锁 // - 实现超时清理 // - 添加监控告警 // Phase 3: 优化完善（3-4周） // - 空回滚自动处理 // - 性能优化 // - 可视化监控 // Phase 4: 高级特性（4-6周） // - 机器学习预测 // - 自适应调整 // - 多级降级策略 }通过以上综合解决方案，可以有效预防和解决TCC事务中的悬挂和空回滚问题，保障分布式事务的可靠性和数据一致性。