订单初版—6.生单链路实现的重构文档

技术分享 8个月前 (07-15) 0 999+

关注

大纲

1.库存服务的数据库与缓存双写的实现

2.如何发起异构存储下的Seata TCC分布式事务

3.异构存储下的Seata TCC分布式事务原理

4.生单链路锁定库存的Seata TCC分布式事务实现

5.库存服务异构存储双写TCC异常处理

6.库存服务TCC事务的空悬挂问题

7.库存服务TCC二阶段重试的幂等问题

8.假设使用异步锁库存方案可能会导致的几种问题

9.生单链路的AT + TCC混合事务方案流程总结

10.生单链路非分布式事务的纯补偿方案

1.库存服务的数据库与缓存双写的实现

(1)生单链路使用Seata AT分布式事务的原理流程图

(2)生单链路Seata AT模式下的并发问题分析

(3)生单链路如何解决库存全局锁争用问题

(4)库存服务双写数据库 + 缓存的实现

(1)生单链路使用Seata AT分布式事务的原理流程图

库存服务写库存时，通常都会进行数据库 + 缓存的双写处理。写缓存是库存服务写库存的一个常规性操作，因为需要支撑高并发的库存扣减。

(2)生单链路Seata AT模式下的并发问题分析

生单链路中的分布式事务环节在于：锁定优惠券 + 锁定库存 + 生成订单。

一.在锁定优惠券环节

每个用户都会有属于自己的优惠券。日常情况下，都是不同的用户使用不同的优惠券购买商品，所以并不会出现并发获取同一优惠券数据的全局锁的情况。

二.在锁定库存环节

对于爆品或秒杀，大量用户可能都会基于某商品进行下单扣减库存，因此会出现并发获取同一个SKU数据的全局锁。

第一个获取到某SKU数据的全局锁的事务，在进行生成订单环节由于需要插入多条SQL，所以可能会比较耗时，从而导致并发等待获取该SKU数据的全局锁的其他事务等待时间过长。

(3)生单链路如何解决库存全局锁争用问题

一.问题分析

一个商品SKU就对应一条库存数据记录。如果大量用户同时购买一个商品SKU，必然导致：多个分布式事务都去竞争和等待同一个SKU库存数据的全局锁。

二.解决方案

方案一：库存分桶方案

例如对库存表进行库存分桶。一般一个SKU就一条库存数据，该方案下一个SKU会有多条库存数据。比如1万的库存可分为1000条库存数据，每条库存数据可扣库存为10。每次扣减库存时，按照一定的规则和算法，选择一个库存分桶去扣减。

方案二：RocketMQ柔性事务方案

通过RocketMQ柔性事务方案来替换掉Seata刚性事务方案。在互联网公司里，一般的业务系统，都是使用RocketMQ柔性事务。大多情况下，RocketMQ柔性事务都能确保数据是一致的。

刚性事务：分支事务出现异常或者失败，则全局回滚。柔性事务：分支事务出现异常或者失败，则不断重试消费，直到成功。使用RocketMQ柔性事务方案，需要确保消息能被投递到RocketMQ。

方案三：使用没有全局锁的分布式事务方案

Seata支持AT、TCC、Saga、XA这几种事务方案。生单链路的建议是：锁定营销使用AT模式 + 锁定库存使用TCC模式的混合分布式事务方案。

三.生单链路中锁库存的技术方案重构

为了提升生单链路的性能，避免扣减库存时出现大量的全局锁争用。锁定库存使用Seata的TCC模式，纳入到全局事务中。而且为了让写库存时双写数据库 + 缓存的数据一致性，也可以用TCC模式实现。

四.存在异构存储的服务解决数据一致性问题的方案

使用Seata分布式事务的TCC模式。

(4)库存服务双写数据库 + 缓存的实现

@RestController @RequestMapping("/inventory") public class InventoryController {     @Autowired     private InventoryService inventoryService;      //新增商品库存     @PostMapping("/addProductStock")     public JsonResult<Boolean> addProductStock(@RequestBody AddProductStockRequest request) {         inventoryService.addProductStock(request);         return JsonResult.buildSuccess(true);     }     ... }  @Service public class InventoryServiceImpl implements InventoryService {     ...     @Override     public Boolean addProductStock(AddProductStockRequest request) {         log.info("新增商品库存：request={}", JSONObject.toJSONString(request));         //1.校验入参         checkAddProductStockRequest(request);          //2.查询商品库存         ProductStockDO productStock = productStockDAO.getBySkuCode(request.getSkuCode());         ParamCheckUtil.checkObjectNull(productStock, InventoryErrorCodeEnum.PRODUCT_SKU_STOCK_EXISTED_ERROR);          //3.添加Redis锁，防并发         String lockKey = RedisLockKeyConstants.ADD_PRODUCT_STOCK_KEY + request.getSkuCode();         Boolean locked = redisLock.lock(lockKey);         if (!locked) {             throw new InventoryBizException(InventoryErrorCodeEnum.ADD_PRODUCT_SKU_STOCK_ERROR);         }          try {             //4.执行添加商品库存逻辑             addProductStockProcessor.doAdd(request);         } finally {             //5.解锁             redisLock.unlock(lockKey);         }         return true;     }     ... }  @Component public class AddProductStockProcessor {     @Autowired     private RedisCache redisCache;      @Autowired     private ProductStockDAO productStockDAO;      //执行添加商品库存逻辑     @Transactional(rollbackFor = Exception.class)     public void doAdd(AddProductStockRequest request) {         //1.构造商品库存         ProductStockDO productStock = buildProductStock(request);         //2.保存商品库存到MySQL         productStockDAO.save(productStock);         //3.保存商品库存到Redis         addStockToRedis(productStock);     }      //保存商品库存到Redis     public void addStockToRedis(ProductStockDO productStock) {         String productStockKey = CacheSupport.buildProductStockKey(productStock.getSkuCode());         Map<String, String> productStockValue = CacheSupport.buildProductStockValue(productStock.getSaleStockQuantity(), productStock.getSaledStockQuantity());         redisCache.hPutAll(productStockKey, productStockValue);     }      private ProductStockDO buildProductStock(AddProductStockRequest request) {         ProductStockDO productStock = new ProductStockDO();         productStock.setSkuCode(request.getSkuCode());         productStock.setSaleStockQuantity(request.getSaleStockQuantity());         productStock.setSaledStockQuantity(0L);         return productStock;     } }  public interface CacheSupport {     String PREFIX_PRODUCT_STOCK = "PRODUCT_STOCK:";     //可销售库存key     String SALE_STOCK = "saleStock";      //已销售库存key     String SALED_STOCK = "saledStock";      //构造缓存商品库存key     static String buildProductStockKey(String skuCode) {         return PREFIX_PRODUCT_STOCK + ":" + skuCode;     }      //构造缓存商品库存value     static Map<String, String> buildProductStockValue(Long saleStockQuantity, Long saledStockQuantity) {         Map<String, String> value = new HashMap<>();         value.put(SALE_STOCK, String.valueOf(saleStockQuantity));         value.put(SALED_STOCK, String.valueOf(saledStockQuantity));         return value;     } }

2.如何发起异构存储下的Seata TCC分布式事务

一.在双写数据库 + 缓存的入口添加Seata的@GlobalTransactional注解。

二.在写数据库接口和写缓存接口上添加Seata的@TwoPhaseBusinessAction注解。

三.在提供双写数据库 + 库存接口的服务上添加Seata的@LocalTCC注解。

3.异构存储下的Seata TCC分布式事务原理

(1)TCC的核心逻辑

(2)TCC的事务流程

(1)TCC的核心逻辑

TCC的核心逻辑就是：try、commit、cancel。

一.try

会预留一些资源，但实际的动作并没有执行，当然实际应用比如写库中也可以直接执行实际的动作即提交SQL。

二.commit

分支事务执行try都成功后，就会让所有分支事务都执行commit，commit会执行实际的动作。

三.cancel

如果存在分支事务try失败了，那么所有分支事务都要执行cancel。执行cancel时会对预留的资源进行逆向补偿，取消资源预留。

(2)TCC的事务流程

4.生单链路锁定库存的Seata TCC分布式事务实现

(1)生单链路中生成订单到扣减库存的实现

(2)库存服务中扣减库存的双写数据库 + 缓存实现

(1)生单链路中生成订单到扣减库存的实现

createOrder()时锁定优惠券 + 生成订单到数据库会使用Seata的AT模式来实现分布式事务。

@DubboService(version = "1.0.0", interfaceClass = OrderApi.class, retries = 0) public class OrderApiImpl implements OrderApi {     @Autowired     private OrderService orderService;     ...      //提交订单/生成订单接口     @Override     public JsonResult<CreateOrderDTO> createOrder(CreateOrderRequest createOrderRequest) {         try {             CreateOrderDTO createOrderDTO = orderService.createOrder(createOrderRequest);             return JsonResult.buildSuccess(createOrderDTO);         } catch (OrderBizException e) {             log.error("biz error", e);             return JsonResult.buildError(e.getErrorCode(), e.getErrorMsg());         } catch (Exception e) {             log.error("system error", e);             return JsonResult.buildError(e.getMessage());         }     }     ... }  @Service public class OrderServiceImpl implements OrderService {     @Autowired     private OrderManager orderManager;     ...      //提交订单/生成订单接口     @Override     public CreateOrderDTO createOrder(CreateOrderRequest createOrderRequest) {         //1.入参检查         checkCreateOrderRequestParam(createOrderRequest);         //2.风控检查         checkRisk(createOrderRequest);         //3.获取商品信息         List<ProductSkuDTO> productSkuList = listProductSkus(createOrderRequest);         //4.计算订单价格         CalculateOrderAmountDTO calculateOrderAmountDTO = calculateOrderAmount(createOrderRequest, productSkuList);         //5.验证订单实付金额         checkRealPayAmount(createOrderRequest, calculateOrderAmountDTO);         //6.生成订单(包含锁定优惠券、扣减库存等逻辑)         createOrder(createOrderRequest, productSkuList, calculateOrderAmountDTO);         //7.发送订单延迟消息用于支付超时自动关单         sendPayOrderTimeoutDelayMessage(createOrderRequest);         //返回订单信息         CreateOrderDTO createOrderDTO = new CreateOrderDTO();         createOrderDTO.setOrderId(createOrderRequest.getOrderId());          return createOrderDTO;     }      //插入订单到数据库     private void createOrder(CreateOrderRequest createOrderRequest, List<ProductSkuDTO> productSkuList, CalculateOrderAmountDTO calculateOrderAmountDTO) {         //插入订单到数据库         orderManager.createOrder(createOrderRequest, productSkuList, calculateOrderAmountDTO);     }     ... }  @Service public class OrderManagerImpl implements OrderManager {     @DubboReference(version = "1.0.0", retries = 0)     private InventoryApi inventoryApi;//库存服务     ...      //生成订单     //由于锁定优惠券不会出现竞争AT模式下的全局锁，所以锁定优惠券+生成订单可以一起使用Seata的AT模式     //但扣减库存继续使用Seata的AT模式则会出现竞争全局锁，所以扣减库存使用Seata的TCC模式     @Override     @GlobalTransactional(rollbackFor = Exception.class)     public void createOrder(CreateOrderRequest createOrderRequest, List<ProductSkuDTO> productSkuList, CalculateOrderAmountDTO calculateOrderAmountDTO) {         //锁定优惠券         lockUserCoupon(createOrderRequest);         //扣减库存         deductProductStock(createOrderRequest);         //生成订单到数据库         addNewOrder(createOrderRequest, productSkuList, calculateOrderAmountDTO);     }      //锁定商品库存     private void deductProductStock(CreateOrderRequest createOrderRequest) {         String orderId = createOrderRequest.getOrderId();         List<DeductProductStockRequest.OrderItemRequest> orderItemRequestList = ObjectUtil.convertList(createOrderRequest.getOrderItemRequestList(), DeductProductStockRequest.OrderItemRequest.class);         DeductProductStockRequest lockProductStockRequest = new DeductProductStockRequest();         lockProductStockRequest.setOrderId(orderId);         lockProductStockRequest.setOrderItemRequestList(orderItemRequestList);         JsonResult<Boolean> jsonResult = inventoryApi.deductProductStock(lockProductStockRequest);         //检查锁定商品库存结果         if (!jsonResult.getSuccess()) {             throw new OrderBizException(jsonResult.getErrorCode(), jsonResult.getErrorMessage());         }     }     ... }  @DubboService(version = "1.0.0", interfaceClass = InventoryApi.class, retries = 0) public class InventoryApiImpl implements InventoryApi {     @Autowired     private InventoryService inventoryService;      //扣减商品库存     @Override     public JsonResult<Boolean> deductProductStock(DeductProductStockRequest deductProductStockRequest) {         try {             Boolean result = inventoryService.deductProductStock(deductProductStockRequest);             return JsonResult.buildSuccess(result);         } catch (InventoryBizException e) {             log.error("biz error", e);             return JsonResult.buildError(e.getErrorCode(), e.getErrorMsg());         } catch (Exception e) {             log.error("system error", e);             return JsonResult.buildError(e.getMessage());         }     }     ... }

(2)库存服务中扣减库存的双写数据库 + 缓存实现

doDeduct()扣减库存时双写数据库 + 缓存会使用Seata的TCC模式来实现分布式事务。TCC模式特别适合这种多写异构存储的业务，关键的注解是@LocalTCC和@TwoPhaseBusinessAction。

@Service public class InventoryServiceImpl implements InventoryService {     ...     //扣减商品库存     @Override     public Boolean deductProductStock(DeductProductStockRequest deductProductStockRequest) {         //检查入参         checkLockProductStockRequest(deductProductStockRequest);         String orderId = deductProductStockRequest.getOrderId();         List<DeductProductStockRequest.OrderItemRequest> orderItemRequestList = deductProductStockRequest.getOrderItemRequestList();         for (DeductProductStockRequest.OrderItemRequest orderItemRequest : orderItemRequestList) {             String skuCode = orderItemRequest.getSkuCode();              //1.查询MySQL库存数据             ProductStockDO productStockDO = productStockDAO.getBySkuCode(skuCode);             if (productStockDO == null) {                 log.error("商品库存记录不存在，skuCode={}", skuCode);                 throw new InventoryBizException(InventoryErrorCodeEnum.PRODUCT_SKU_STOCK_NOT_FOUND_ERROR);             }              //2.查询Redis库存数据             String productStockKey = CacheSupport.buildProductStockKey(skuCode);             Map<String, String> productStockValue = redisCache.hGetAll(productStockKey);             if (productStockValue.isEmpty()) {                 //如果查询不到Redis库存数据，将MySQL库存数据放入Redis，以MySQL的数据为准                 addProductStockProcessor.addStockToRedis(productStockDO);             }              //3.添加Redis锁，防并发             String lockKey = MessageFormat.format(RedisLockKeyConstants.DEDUCT_PRODUCT_STOCK_KEY, orderId, skuCode);             Boolean locked = redisLock.lock(lockKey);             if (!locked) {                 log.error("无法获取扣减库存锁,orderId={},skuCode={}", orderId, skuCode);                 throw new InventoryBizException(InventoryErrorCodeEnum.DEDUCT_PRODUCT_SKU_STOCK_ERROR);             }              try {                 //4.查询库存扣减日志                 ProductStockLogDO productStockLog = productStockLogDAO.getLog(orderId, skuCode);                 if (null != productStockLog) {                     log.info("已扣减过，扣减库存日志已存在,orderId={},skuCode={}", orderId, skuCode);                     return true;                 }                 Integer saleQuantity = orderItemRequest.getSaleQuantity();                 Integer originSaleStock = productStockDO.getSaleStockQuantity().intValue();                 Integer originSaledStock = productStockDO.getSaledStockQuantity().intValue();                  //5.执行执库存扣减                 DeductStockDTO deductStock = new DeductStockDTO(orderId, skuCode, saleQuantity, originSaleStock, originSaledStock);                 deductProductStockProcessor.doDeduct(deductStock);             } finally {                 redisLock.unlock(lockKey);             }         }         return true;     }     ... }  //扣减商品库存处理器 @Component public class DeductProductStockProcessor {     @Autowired     private LockMysqlStockTccService lockMysqlStockTccService;      @Autowired     private LockRedisStockTccService lockRedisStockTccService;      @Autowired     private ProductStockLogDAO productStockLogDAO;      //执行扣减商品库存逻辑，由于createOrder()已经加了@GlobalTransactional注解，这里就不用加了     //@GlobalTransactional(rollbackFor = Exception.class)     public void doDeduct(DeductStockDTO deductStock) {         //1.执行执行MySQL库存扣减，就是执行TCC的try         boolean result = lockMysqlStockTccService.deductStock(null, deductStock);         if (!result) {             throw new InventoryBizException(InventoryErrorCodeEnum.PRODUCT_SKU_STOCK_NOT_FOUND_ERROR);         }          //2.执行Redis库存扣减，就是执行TCC的try         result = lockRedisStockTccService.deductStock(null, deductStock);         if (!result) {             throw new InventoryBizException(InventoryErrorCodeEnum.PRODUCT_SKU_STOCK_NOT_FOUND_ERROR);         }     } }  //锁定MySQL库存，Seata TCC模式的Service @LocalTCC public interface LockMysqlStockTccService {     //一阶段方法：扣减销售库存(saleStockQuantity-saleQuantity)，这就是TCC中的try     //所有分支事务的try执行成功，则所有事务执行commit方法；     //存在分支事务的try执行失败，则所有事务执行rollback方法；     @TwoPhaseBusinessAction(name = "lockMysqlStockTccService", commitMethod = "commit", rollbackMethod = "rollback")     boolean deductStock(BusinessActionContext actionContext, @BusinessActionContextParameter(paramName = "deductStock") DeductStockDTO deductStock);      //二阶段方法：增加已销售库存(saledStockQuantity+saleQuantity)，这就是TCC中的commit     void commit(BusinessActionContext actionContext);      //回滚：增加销售库存(saleStockQuantity+saleQuantity)，这就是TCC中的cancel     void rollback(BusinessActionContext actionContext); }  //锁定Redis库存，Seata TCC模式的Service @LocalTCC public interface LockRedisStockTccService {     //一阶段方法：扣减销售库存(saleStockQuantity-saleQuantity)，这就是TCC中的try     //所有分支事务的try执行成功，则所有事务执行commit方法；     //存在分支事务的try执行失败，则所有事务执行rollback方法；     @TwoPhaseBusinessAction(name = "lockRedisStockTccService", commitMethod = "commit", rollbackMethod = "rollback")     boolean deductStock(BusinessActionContext actionContext, @BusinessActionContextParameter(paramName = "deductStock") DeductStockDTO deductStock);      //二阶段方法：增加已销售库存(saledStockQuantity+saleQuantity)，这就是TCC中的commit     void commit(BusinessActionContext actionContext);      //回滚：增加销售库存(saleStockQuantity+saleQuantity)，这就是TCC中的cancel     void rollback(BusinessActionContext actionContext); }

其中，try操作可以是预留资源，也可以是直接执行动作(即等于commit)。比如锁库存，会在try操作中把写数据库或写缓存直接处理了。try操作具体是预留资源还是直接执行，往往会根据业务来决定。

@Service public class LockMysqlStockTccServiceImpl implements LockMysqlStockTccService {     ...     @Transactional(rollbackFor = Exception.class)     @Override     public boolean deductStock(BusinessActionContext actionContext, DeductStockDTO deductStock) {         //actionContext上下文获取全局事务xid         String xid = actionContext.getXid();         String skuCode = deductStock.getSkuCode();         Integer saleQuantity = deductStock.getSaleQuantity();         Integer originSaleStock = deductStock.getOriginSaleStock();         Integer originSaledStock = deductStock.getOriginSaledStock();          //标识try阶段开始执行         TccResultHolder.tagTryStart(getClass(), skuCode, xid);          if (isEmptyRollback()) {             return false;         }         log.info("一阶段方法：扣减MySQL销售库存，deductStock={},xid={}", JSONObject.toJSONString(deductStock), xid);          int result = productStockDAO.deductSaleStock(skuCode, saleQuantity, originSaleStock);         //标识try阶段执行成功         if (result > 0) {             TccResultHolder.tagTrySuccess(getClass(), skuCode, xid);         }         return result > 0;     }     ... }  @Service public class LockRedisStockTccServiceImpl implements LockRedisStockTccService {     ...     @Override     public boolean deductStock(BusinessActionContext actionContext, DeductStockDTO deductStock) {         String xid = actionContext.getXid();         String skuCode = deductStock.getSkuCode();         Integer saleQuantity = deductStock.getSaleQuantity();         Integer originSaleStock = deductStock.getOriginSaleStock();         Integer originSaledStock = deductStock.getOriginSaledStock();          //标识try阶段开始执行         TccResultHolder.tagTryStart(getClass(), skuCode, xid);         log.info("一阶段方法：扣减redis销售库存，deductStock={},xid={}", JSONObject.toJSONString(deductStock), xid);         if (isEmptyRollback()) {             return false;         }         String luaScript = LuaScript.DEDUCT_SALE_STOCK;         String saleStockKey = CacheSupport.SALE_STOCK;         String productStockKey = CacheSupport.buildProductStockKey(skuCode);         Long result = redisCache.execute(new DefaultRedisScript<>(luaScript, Long.class),             Arrays.asList(productStockKey, saleStockKey), String.valueOf(saleQuantity), String.valueOf(originSaleStock));          //标识try阶段执行成功         if (result > 0) {             TccResultHolder.tagTrySuccess(getClass(), skuCode, xid);         }         return result > 0;     }     ... }  //存储TCC第一阶段执行结果，用于解决TCC幂等，空回滚，悬挂问题 public class TccResultHolder {     //标识TCC try阶段开始执行的标识     private static final String TRY_START = "TRY_START";      //标识TCC try阶段执行成功的标识     private static final String TRY_SUCCESS = "TRY_SUCCESS";      //保存TCC事务执行过程的状态     private static Map<Class<?>, Map<String, String>> map = new ConcurrentHashMap<Class<?>, Map<String, String>>();     ...      //标记try阶段开始执行     public static void tagTryStart(Class<?> tccClass, String bizKey, String xid) {         setResult(tccClass, bizKey, xid, TRY_START);     }          //标记try阶段执行成功     public static void tagTrySuccess(Class<?> tccClass, String bizKey, String xid) {         setResult(tccClass, bizKey, xid, TRY_SUCCESS);     }      //一个tccClass代表了TCC的一个分支事务     public static void setResult(Class<?> tccClass, String bizKey, String xid, String v) {         Map<String, String> results = map.get(tccClass);         if (results == null) {             synchronized (map) {                 if (results == null) {                     results = new ConcurrentHashMap<>();                     map.put(tccClass, results);                 }             }         }         results.put(getTccExecution(xid, bizKey), v);//保存当前分布式事务id     }     ... }

5.库存服务异构存储双写TCC异常处理

只要TCC的分支事务在try过程中出现异常，都需要回滚所有分支事务。

如果没有出现异常，则执行commit()方法。如果出现异常，则执行rollback()方法。

//锁定MySQL库存，Seata TCC模式的Service @LocalTCC public interface LockMysqlStockTccService {     //一阶段方法：扣减销售库存(saleStockQuantity-saleQuantity)，这就是TCC中的try     //所有分支事务的try执行成功，则所有事务执行commit方法；     //存在分支事务的try执行失败，则所有事务执行rollback方法；     @TwoPhaseBusinessAction(name = "lockMysqlStockTccService", commitMethod = "commit", rollbackMethod = "rollback")     boolean deductStock(BusinessActionContext actionContext, @BusinessActionContextParameter(paramName = "deductStock") DeductStockDTO deductStock);      //二阶段方法：增加已销售库存(saledStockQuantity+saleQuantity)，这就是TCC中的commit     void commit(BusinessActionContext actionContext);      //回滚：增加销售库存(saleStockQuantity+saleQuantity)，这就是TCC中的cancel     void rollback(BusinessActionContext actionContext); }  //锁定Redis库存，Seata TCC模式的Service @LocalTCC public interface LockRedisStockTccService {     //一阶段方法：扣减销售库存(saleStockQuantity-saleQuantity)，这就是TCC中的try     //所有分支事务的try执行成功，则所有事务执行commit方法；     //存在分支事务的try执行失败，则所有事务执行rollback方法；     @TwoPhaseBusinessAction(name = "lockRedisStockTccService", commitMethod = "commit", rollbackMethod = "rollback")     boolean deductStock(BusinessActionContext actionContext, @BusinessActionContextParameter(paramName = "deductStock") DeductStockDTO deductStock);      //二阶段方法：增加已销售库存(saledStockQuantity+saleQuantity)，这就是TCC中的commit     void commit(BusinessActionContext actionContext);      //回滚：增加销售库存(saleStockQuantity+saleQuantity)，这就是TCC中的cancel     void rollback(BusinessActionContext actionContext); }

写数据库的commit()和rollback()：

@Service public class LockMysqlStockTccServiceImpl implements LockMysqlStockTccService {     @Autowired     private ProductStockDAO productStockDAO;      @Autowired     private ProductStockLogDAO productStockLogDAO;     ...      @Override     public void commit(BusinessActionContext actionContext) {         String xid = actionContext.getXid();         DeductStockDTO deductStock = ((JSONObject) actionContext.getActionContext("deductStock")).toJavaObject(DeductStockDTO.class);         String skuCode = deductStock.getSkuCode();         Integer saleQuantity = deductStock.getSaleQuantity();         Integer originSaleStock = deductStock.getOriginSaleStock();         Integer originSaledStock = deductStock.getOriginSaledStock();         log.info("二阶段方法：增加mysql已销售库存，deductStock,xid={}", JSONObject.toJSONString(deductStock), xid);          //幂等         //当出现网络异常或者TC Server异常时，会出现重复调用commit阶段的情况，所以需要进行幂等操作         if (!TccResultHolder.isTrySuccess(getClass(), skuCode, xid)) {             return;         }          //1.增加已销售库存         productStockDAO.increaseSaledStock(skuCode, saleQuantity, originSaledStock);          //2.插入一条扣减日志表         log.info("插入一条扣减日志表");         productStockLogDAO.save(buildStockLog(deductStock));          //移除标识         TccResultHolder.removeResult(getClass(), skuCode, xid);     }      @Override     public void rollback(BusinessActionContext actionContext) {         String xid = actionContext.getXid();         DeductStockDTO deductStock = ((JSONObject) actionContext.getActionContext("deductStock")).toJavaObject(DeductStockDTO.class);         String skuCode = deductStock.getSkuCode();         Integer saleQuantity = deductStock.getSaleQuantity();         Integer originSaleStock = deductStock.getOriginSaleStock();         Integer originSaledStock = deductStock.getOriginSaledStock();         log.info("回滚：增加mysql销售库存，deductStock={},xid={}", JSONObject.toJSONString(deductStock), xid);          //空回滚处理         if (TccResultHolder.isTagNull(getClass(), skuCode, xid)) {             log.info("mysql:出现空回滚");             insertEmptyRollbackTag();             return;         }          //幂等处理         //try阶段没有完成的情况下，不必执行回滚，因为try阶段有本地事务，事务失败时已经进行了回滚         //如果try阶段成功，而其他全局事务参与者失败，这里会执行回滚         if (!TccResultHolder.isTrySuccess(getClass(), skuCode, xid)) {             log.info("mysql:无需回滚");             return;         }          //1.还原销售库存         productStockDAO.restoreSaleStock(skuCode, saleQuantity, originSaleStock - saleQuantity);          //2.删除库存扣减日志         ProductStockLogDO logDO = productStockLogDAO.getLog(deductStock.getOrderId(), skuCode);         if (null != logDO) {             productStockLogDAO.removeById(logDO.getId());         }          //移除标识         TccResultHolder.removeResult(getClass(), skuCode, xid);     }     ... }

写缓存的commit()和rollback()：

@Service public class LockRedisStockTccServiceImpl implements LockRedisStockTccService {     @Autowired     private RedisCache redisCache;     ...      @Override     public void commit(BusinessActionContext actionContext) {         String xid = actionContext.getXid();         DeductStockDTO deductStock = ((JSONObject) actionContext.getActionContext("deductStock")).toJavaObject(DeductStockDTO.class);         String skuCode = deductStock.getSkuCode();         Integer saleQuantity = deductStock.getSaleQuantity();         Integer originSaleStock = deductStock.getOriginSaleStock();         Integer originSaledStock = deductStock.getOriginSaledStock();         log.info("二阶段方法：增加redis已销售库存，deductStock={},xid={}", JSONObject.toJSONString(deductStock), xid);          //幂等         //当出现网络异常或者TC Server异常时，会出现重复调用commit阶段的情况，所以需要进行幂等操作         if (!TccResultHolder.isTrySuccess(getClass(), skuCode, xid)) {             log.info("已经执行过commit阶段");             return;         }          String luaScript = LuaScript.INCREASE_SALED_STOCK;         String saledStockKey = CacheSupport.SALED_STOCK;         String productStockKey = CacheSupport.buildProductStockKey(skuCode);         redisCache.execute(new DefaultRedisScript<>(luaScript, Long.class), Arrays.asList(productStockKey, saledStockKey), String.valueOf(saleQuantity), String.valueOf(originSaledStock));          //移除标识         TccResultHolder.removeResult(getClass(), skuCode, xid);     }      @Override     public void rollback(BusinessActionContext actionContext) {         String xid = actionContext.getXid();         DeductStockDTO deductStock = ((JSONObject) actionContext.getActionContext("deductStock")).toJavaObject(DeductStockDTO.class);         String skuCode = deductStock.getSkuCode();         Integer saleQuantity = deductStock.getSaleQuantity();         Integer originSaleStock = deductStock.getOriginSaleStock();         Integer originSaledStock = deductStock.getOriginSaledStock();         log.info("回滚：增加redis销售库存，deductStock={},xid={}", JSONObject.toJSONString(deductStock), xid);          //空回滚处理         if (TccResultHolder.isTagNull(getClass(), skuCode, xid)) {             log.info("redis:出现空回滚");             insertEmptyRollbackTag();             return;         }          //幂等处理         //try阶段没有完成的情况下，不必执行回滚         //如果try阶段成功，而其他全局事务参与者失败，这里会执行回滚         if (!TccResultHolder.isTrySuccess(getClass(), skuCode, xid)) {             log.info("redis:无需回滚");             return;         }          String luaScript = LuaScript.RESTORE_SALE_STOCK;         String saleStockKey = CacheSupport.SALE_STOCK;         String productStockKey = CacheSupport.buildProductStockKey(skuCode);         redisCache.execute(new DefaultRedisScript<>(luaScript, Long.class), Arrays.asList(productStockKey, saleStockKey), String.valueOf(saleQuantity), String.valueOf(originSaleStock - saleQuantity));          //移除标识         TccResultHolder.removeResult(getClass(), skuCode, xid);     }     ... }

6.库存服务TCC事务的空悬挂问题

(1)空悬挂问题

(2)解决空悬挂的思路

(1)空悬挂问题

因为网络延迟等原因，分支事务的rollback()方法可能会比try()方法先执行，即rollback()方法进行了空回滚，然后try()方法才执行，从而导致try()方法预留的资源无法被取消。

(2)解决空悬挂的思路

当rollback()方法出现空回滚时，需要进行标识(如在数据库中查一条记录)，然后在try()方法里会判断是否发生了空回滚。

@Service public class LockMysqlStockTccServiceImpl implements LockMysqlStockTccService {     ...     //这就是TCC的try     @Transactional(rollbackFor = Exception.class)     @Override     public boolean deductStock(BusinessActionContext actionContext, DeductStockDTO deductStock) {         //actionContext上下文获取全局事务xid         String xid = actionContext.getXid();         String skuCode = deductStock.getSkuCode();         Integer saleQuantity = deductStock.getSaleQuantity();         Integer originSaleStock = deductStock.getOriginSaleStock();         Integer originSaledStock = deductStock.getOriginSaledStock();          //标识try阶段开始执行         TccResultHolder.tagTryStart(getClass(), skuCode, xid);          //悬挂问题：rollback接口比try接口先执行，即rollback接口进行了空回滚，try接口才执行，导致try接口预留的资源无法被取消         //解决空悬挂的思路：即当rollback接口出现空回滚时，需要打一个标识(在数据库中查一条记录)，在try()里判断是否发生了空回滚         if (isEmptyRollback()) {             return false;         }         log.info("一阶段方法：扣减MySQL销售库存，deductStock={},xid={}", JSONObject.toJSONString(deductStock), xid);          int result = productStockDAO.deductSaleStock(skuCode, saleQuantity, originSaleStock);         //标识try阶段执行成功         if (result > 0) {             TccResultHolder.tagTrySuccess(getClass(), skuCode, xid);         }          return result > 0;     }      //判断是否发生的空回滚     private Boolean isEmptyRollback() {         //需要查询本地数据库，看是否发生了空回滚         return false;     }      //插入空回滚标识     private void insertEmptyRollbackTag() {         //在数据库插入空回滚的标识     }      @Override     public void rollback(BusinessActionContext actionContext) {         String xid = actionContext.getXid();         DeductStockDTO deductStock = ((JSONObject) actionContext.getActionContext("deductStock")).toJavaObject(DeductStockDTO.class);         String skuCode = deductStock.getSkuCode();         Integer saleQuantity = deductStock.getSaleQuantity();         Integer originSaleStock = deductStock.getOriginSaleStock();         Integer originSaledStock = deductStock.getOriginSaledStock();         log.info("回滚：增加mysql销售库存，deductStock={},xid={}", JSONObject.toJSONString(deductStock), xid);          //空回滚处理         if (TccResultHolder.isTagNull(getClass(), skuCode, xid)) {             log.info("mysql:出现空回滚");             //插入空回滚标识             insertEmptyRollbackTag();             return;         }          //幂等处理         //try阶段没有完成的情况下，不必执行回滚，因为try阶段有本地事务，事务失败时已经进行了回滚         //如果try阶段成功，而其他全局事务参与者失败，这里会执行回滚         if (!TccResultHolder.isTrySuccess(getClass(), skuCode, xid)) {             log.info("mysql:无需回滚");             return;         }          //1.还原销售库存         productStockDAO.restoreSaleStock(skuCode, saleQuantity, originSaleStock - saleQuantity);          //2.删除库存扣减日志         ProductStockLogDO logDO = productStockLogDAO.getLog(deductStock.getOrderId(), skuCode);         if (null != logDO) {             productStockLogDAO.removeById(logDO.getId());         }          //移除标识         TccResultHolder.removeResult(getClass(), skuCode, xid);     }     ... }

7.库存服务TCC二阶段重试的幂等问题

如果执行commit失败，Seata Server会让分支事务不断重试commit。如果执行cancel失败，Seata Server会让分支事务不断重试cancel。只要出现重试，就需要保证重试操作的方法是幂等的。

当try开始执行时，会添加标识，表明开启了TCC事务。当标识被移除掉后，则说明commit或cancel执行成功。

重复执行commit或cancel时，通过判断标识是否为空，就能拦截掉重复执行的commit或cancel，从而实现幂等。

@Service public class LockMysqlStockTccServiceImpl implements LockMysqlStockTccService {     @Autowired     private ProductStockDAO productStockDAO;      @Autowired     private ProductStockLogDAO productStockLogDAO;     ...      @Override     public void commit(BusinessActionContext actionContext) {         String xid = actionContext.getXid();         DeductStockDTO deductStock = ((JSONObject) actionContext.getActionContext("deductStock")).toJavaObject(DeductStockDTO.class);         String skuCode = deductStock.getSkuCode();         Integer saleQuantity = deductStock.getSaleQuantity();         Integer originSaleStock = deductStock.getOriginSaleStock();         Integer originSaledStock = deductStock.getOriginSaledStock();         log.info("二阶段方法：增加mysql已销售库存，deductStock,xid={}", JSONObject.toJSONString(deductStock), xid);          //幂等         //当出现网络异常或者TC Server异常时，会出现重复调用commit阶段的情况，所以需要进行幂等操作         if (!TccResultHolder.isTrySuccess(getClass(), skuCode, xid)) {             return;         }          //1.增加已销售库存         productStockDAO.increaseSaledStock(skuCode, saleQuantity, originSaledStock);          //2.插入一条扣减日志表         log.info("插入一条扣减日志表");         productStockLogDAO.save(buildStockLog(deductStock));          //移除标识         TccResultHolder.removeResult(getClass(), skuCode, xid);     }      @Override     public void rollback(BusinessActionContext actionContext) {         String xid = actionContext.getXid();         DeductStockDTO deductStock = ((JSONObject) actionContext.getActionContext("deductStock")).toJavaObject(DeductStockDTO.class);         String skuCode = deductStock.getSkuCode();         Integer saleQuantity = deductStock.getSaleQuantity();         Integer originSaleStock = deductStock.getOriginSaleStock();         Integer originSaledStock = deductStock.getOriginSaledStock();         log.info("回滚：增加mysql销售库存，deductStock={},xid={}", JSONObject.toJSONString(deductStock), xid);          //空回滚处理         if (TccResultHolder.isTagNull(getClass(), skuCode, xid)) {             log.info("mysql:出现空回滚");             insertEmptyRollbackTag();             return;         }          //幂等处理         //try阶段没有完成的情况下，不必执行回滚，因为try阶段有本地事务，事务失败时已经进行了回滚         //如果try阶段成功，而其他全局事务参与者失败，这里会执行回滚         if (!TccResultHolder.isTrySuccess(getClass(), skuCode, xid)) {             log.info("mysql:无需回滚");             return;         }          //1.还原销售库存         productStockDAO.restoreSaleStock(skuCode, saleQuantity, originSaleStock - saleQuantity);          //2.删除库存扣减日志         ProductStockLogDO logDO = productStockLogDAO.getLog(deductStock.getOrderId(), skuCode);         if (null != logDO) {             productStockLogDAO.removeById(logDO.getId());         }          //移除标识         TccResultHolder.removeResult(getClass(), skuCode, xid);     }     ... }  //存储TCC第一阶段执行结果，用于解决TCC幂等，空回滚，悬挂问题 public class TccResultHolder {     //标识TCC try阶段开始执行的标识     private static final String TRY_START = "TRY_START";      //标识TCC try阶段执行成功的标识     private static final String TRY_SUCCESS = "TRY_SUCCESS";      //保存TCC事务执行过程的状态     private static Map<Class<?>, Map<String, String>> map = new ConcurrentHashMap<Class<?>, Map<String, String>>();     ...      //判断try阶段是否执行成功     public static boolean isTrySuccess(Class<?> tccClass, String bizKey, String xid) {         String v = getResult(tccClass, bizKey, xid);         if (StringUtils.isNotBlank(v) && TRY_SUCCESS.equals(v)) {             return true;         }         return false;     }      public static String getResult(Class<?> tccClass, String bizKey, String xid) {         Map<String, String> results = map.get(tccClass);         if (results != null) {             return results.get(getTccExecution(xid, bizKey));         }         return null;     }      public static void removeResult(Class<?> tccClass, String bizKey, String xid) {         Map<String, String> results = map.get(tccClass);         if (results != null) {             results.remove(getTccExecution(xid, bizKey));         }     }     ... }

8.假设使用异步锁库存方案可能会导致的几种问题

(1)发送库存扣减消息到MQ失败导致超卖

(2)消费库存扣减消息失败重试时出现重复消费

(3)大量并发扣减请求进来扣库存导致大量扣减失败

假如锁定优惠券 + 生成订单数据写库之后，通过发送库存扣减消息到MQ。后续再由消费者消费MQ的库存扣减消息，完成数据库 + 缓存的双写。通过这种异步锁库存的方式，来实现隔离Seata AT模式和Seata TCC模式。那么就可能会出现如下问题：

(1)发送库存扣减消息到MQ失败导致超卖

比如10个库存，发了11次消息，其中1次失败，那么就会造成10个库存扣完了，但是生成了11个订单。

(2)消费库存扣减消息失败重试时出现重复消费

比如10个库存，发了9次消息，其中一条消息重复消费了两次。这样库存扣完了，但只生成9个订单。

(3)大量并发扣减请求进来扣库存导致大量扣减失败

出现生成订单成功，但是后续出现大量扣库存失败，导致退款。

所以，异步锁库存并不科学，锁库存还是要使用同步。也就是生成订单到数据库 + 锁优惠券 + 锁库存，使用AT模式绑定成刚性事务。但由于锁库存使用了TCC模式，所以锁库存的分支事务不用再竞争全局锁，从而提高了锁库存的并发性能，而且TCC模式也保证了双写数据库 + 缓存的数据一致性。