项目中如何防止超卖

什么是超卖？假如只剩下一个库存，却被多个订单买到了，简单理解就是库存不够了还能正常下单。

---

方案1：数据库行级锁

1. 实体类

@Data
@TableName("product")
public class Product {
    @TableId(type = IdType.AUTO)
    private Long id;
    
    private String name;
    
    private Integer stock;
    
    @Version // MyBatis-Plus乐观锁注解
    private Integer version;
}

2. Mapper接口

public interface ProductMapper extends BaseMapper<Product> {
    /​**​
     * 使用悲观锁查询商品
     * @param id 商品ID
     * @return 商品实体
     */
    @Select("SELECT * FROM product WHERE id = #{id} FOR UPDATE")
    Product selectByIdWithLock(Long id);

    /​**​
     * 自定义乐观锁更新方法
     * @param product 商品实体
     * @param oldVersion 旧版本号
     * @return 更新影响行数
     */
    @Update("UPDATE product SET stock = #{stock}, version = version + 1 " +
            "WHERE id = #{id} AND version = #{oldVersion}")
    int updateWithOptimisticLock(Product product, @Param("oldVersion") int oldVersion);
}

3. Service层实现

@Service
@RequiredArgsConstructor
public class ProductService {
    private final ProductMapper productMapper;
    
    /​**​
     * 使用行级锁扣减库存
     * @param productId 商品ID
     * @param quantity 扣减数量
     * @return 操作结果
     */
    @Transactional(rollbackFor = Exception.class)
    public String reduceStock(Long productId, Integer quantity) {
        try {
            // 1. 加行级锁查询商品
            Product product = productMapper.selectByIdWithLock(productId);
            if (product == null) {
                return "商品不存在";
            }
            
            // 2. 检查库存是否充足
            if (product.getStock() < quantity) {
                return "库存不足";
            }
            
            // 3. 扣减库存
            product.setStock(product.getStock() - quantity);
            
            // 4. 更新库存
            int result = productMapper.updateById(product);
            if (result <= 0) {
                throw new RuntimeException("更新库存失败");
            }
            
            return "扣减库存成功";
        } catch (Exception e) {
            // 事务回滚
            throw new RuntimeException("扣减库存异常: " + e.getMessage());
        }
    }
    
    /​**​
     * 使用MyBatis-Plus内置乐观锁机制扣减库存
     * @param productId 商品ID
     * @param quantity 扣减数量
     * @return 操作结果
     */
    @Transactional(rollbackFor = Exception.class)
    public String reduceStockWithOptimisticLock(Long productId, Integer quantity) {
        // 1. 查询商品(不加锁)
        Product product = productMapper.selectById(productId);
        if (product == null) {
            return "商品不存在";
        }
        
        // 2. 检查库存
        if (product.getStock() < quantity) {
            return "库存不足";
        }
        
        // 3. 扣减库存
        product.setStock(product.getStock() - quantity);
        
        // 4. 乐观锁更新
        int result = productMapper.updateById(product);
        if (result <= 0) {
            // 版本号不一致，说明数据已被修改
            return "操作失败，请重试";
        }
        
        return "扣减库存成功";
    }

    /​**​
     * 手动实现乐观锁扣减库存（带重试机制）
     * @param productId 商品ID
     * @param quantity 扣减数量
     * @return 操作结果
     */
    @Transactional(rollbackFor = Exception.class)
    public String reduceStockManual(Long productId, int quantity) {
        // 1. 查询商品
        Product product = productMapper.selectById(productId);
        if (product == null) {
           return "商品不存在";
        }
            
        // 2. 检查库存是否充足
        if (product.getStock() < quantity) {
           return "库存不足";
        }
            
        // 3. 扣减库存
        product.setStock(product.getStock() - quantity);
            
        // 4. 手动乐观锁更新
        int result = productMapper.updateWithOptimisticLock(
        product, product.getVersion());
            
        if (result > 0) {
           return "扣减库存成功";
        }
            
        
        return "操作失败，请重试";
    }
}

方案2：分布式锁

1. 实体类

@Data
@TableName("product")
public class Product {
    @TableId(type = IdType.AUTO)
    private Long id;
    
    private String name;
    
    private Integer stock;
}

2. Mapper接口

public interface ProductMapper extends BaseMapper<Product> {
    // 使用MyBatis-Plus自带方法
    
    /​**​
     * 自定义扣减库存方法
     * @param productId 商品ID
     * @param quantity 扣减数量
     * @return 影响行数
     */
    @Update("UPDATE product SET stock = stock - #{quantity} WHERE id = #{productId} AND stock >= #{quantity}")
    int reduceStock(@Param("productId") Long productId, @Param("quantity") int quantity);
}

3. Service层实现

@Service
@RequiredArgsConstructor
public class ProductService {
    private final ProductMapper productMapper;
    private final RedissonClient redissonClient;
    
    
    /​**​
     * Redisson分布式锁
     */
    public String reduceStockWithLock(Long productId, int quantity) {
        // 1. 创建分布式锁key
        String lockKey = "product:lock:" + productId;
        RLock lock = redissonClient.getLock(lockKey);
        
        try {
            // 2. 尝试获取锁（等待5秒，锁自动释放时间30秒）
            boolean locked = lock.tryLock(5, 30, TimeUnit.SECONDS);
            if (!locked) {
                return "系统繁忙，请稍后再试";
            }
            
            try {
                // 3. 查询商品
                Product product = productMapper.selectById(productId);
                if (product == null) {
                    return "商品不存在";
                }
                
                // 4. 检查库存是否充足
                if (product.getStock() < quantity) {
                    return "库存不足";
                }
                
                // 5. 扣减库存
                int result = productMapper.reduceStock(productId, quantity);
                if (result <= 0) {
                    return "扣减失败，请重试";
                }
                
                return "扣减成功";
            } finally {
                // 6. 释放锁
                // lock.isLocked()检查锁是否仍然被持有（未被释放）
                // lock.isHeldByCurrentThread()检查当前线程是否持有该锁
                if (lock.isLocked() && lock.isHeldByCurrentThread()) {
                    lock.unlock();
                }
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return "系统异常，请重试";
        }
    }
}