秒杀背后的秘密：如何用技术避免库存超卖

最新推荐文章于 2024-12-16 14:20:14 发布

逆流的小鱼168

最新推荐文章于 2024-12-16 14:20:14 发布

阅读量841

点赞数 29

分类专栏： Java 多线程后端文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/feiying101/article/details/138766759

版权

Java 同时被 3 个专栏收录

101 篇文章

订阅专栏

后端

90 篇文章

订阅专栏

多线程

64 篇文章

订阅专栏

1. 秒杀系统概述

1.1. 秒杀系统的特点

秒杀系统以其独特的促销模式吸引了广泛的关注。它允许消费者在限定的时间内以大幅折扣的价格购买限量商品。这种促销方式在电商平台中非常常见，尤其在双十一、黑五等大型购物节日期间。秒杀的主要特征包括：

时间敏感性：秒杀活动通常在预定时间窗口内开始和结束，这要求参与用户准时参与。
高并发请求：由于大折扣的吸引力，成千上万的用户可能会在活动开始的同一时刻冲击系统。
库存限制：商品数量有限，一旦库存售罄，其他用户就无法购买。

1.2. 秒杀系统面临的挑战

面对海量并发用户的请求，秒杀系统必须在保证用户公平性的同时，确保系统的稳定、快速响应和数据准确性。面临的主要挑战包括：

系统可用性：系统必须足够稳固，以应对巨大的流量冲击。
数据一致性：在并发环境中计算和维护库存，防止数据错误。
反作弊机制：防止脚本或刷单行为破坏秒杀的公平性。

2. 库存超卖问题剖析

2.1. 库存超卖的原因

库存超卖是电商平台中一个普遍存在的难题，特别是在高并发秒杀场景下。库存超卖的原因主要有两个：

并发写入导致数据不一致：当多个用户同时下单时，如果库存的扣减不是原子操作，那么就可能出现多个用户都能下单成功，导致实际卖出的数量超过库存。
系统延迟导致信息不同步：库存信息的更新可能会由于系统的处理延迟，导致用户看到的库存量与实际库存量不符。

2.2. 库存超卖的后果

库存超卖对业务影响重大，可能导致消费者不满、损害企业声誉，并在后续需要处理诸多订单取消和客服问题。具体后果如下：

用户体验差：购买成功后却告知商品缺货，影响用户体验和满意度。
运营成本增加：处理超卖后果需要额外的客服支持和运营资源，增加公司运营成本。
商誉损失：频繁的库存问题会使得消费者对品牌失去信心。

3. 扣减库存的方式

3.1. 下单减库存策略

3.1.1. 实现流程

下单即减库存是一种通常的实践选项，即在用户下单的瞬间减去对应的库存量。它的核心逻辑包括以下步骤：

用户下单操作时，系统首先检查库存量。
如果库存充足，系统扣减相应数量的库存。
系统生成订单，标记该用户已购置商品。

实际操作中，可以用如下伪代码表示：

@Transactional
public boolean placeOrder(User user, Product product, int quantity) {
    // 检查库存
    if (product.getStock() >= quantity) {
        // 扣减库存
        product.setStock(product.getStock() - quantity);
        repository.save(product);
        
        // 创建订单
        Order order = new Order(user, product, quantity);
        orderRepository.save(order);
        return true;
    } else {
        // 库存不足
        return false;
    }
}

3.1.2. 存在的问题

这种流程的问题在于它基于“先到先得”的机制，可能不适用于所有业务场景。比如在高并发场景下，仍然可能存在超卖的风险。

3.2. 付款减库存策略

3.2.1. 实现流程

付款减库存意味着只有当用户完成支付后，系统才执行库存扣减。这可以通过以下步骤实现：

用户下单但不扣减库存。
用户完成支付操作。
系统验证支付成功后，扣减相应的库存量。

这样做的目的是确保只有真正意愿购买的用户才占用库存，可以用以下伪代码表示：

@Transactional
public boolean confirmPayment(User user, Product product, int quantity) {
    // 支付成功后操作
    if (paymentSuccess(user, product, quantity)) {
        // 扣减库存
        synchronized (product){
            if (product.getStock() >= quantity) {
                product.setStock(product.getStock() - quantity);
                repository.save(product);
                
                // 更新订单状态为已支付
                Order order = orderRepository.findByUserAndProduct(user, product);
                order.setStatus(PAID);
                orderRepository.save(order);
                return true;
            }
        }
    }
    
    return false;
}

3.2.2. 存在的问题

延后库存减少会使未付款的订单在一定时间内占用库存，影响其他用户的购买。同时，如果在支付阶段系统出现故障，可能导致库存同步问题。

4. 扣减库存问题的解决方案

库存扣减在高并发秒杀系统中是核心问题之一，正确地管理库存数量对于防止超卖至关重要。解决这一问题通常涉及数据库层面和应用层面的多种策略与技术。

4.1. 数据库层面的优化

数据库是存储和管理库存数据的核心，因此对数据库进行优化是解决库存问题的第一步。

4.1.1. 乐观锁

乐观锁是一种在数据库层面预防并发问题的机制。它基于“冲突检测再处理”的策略。在应用中，可以通过在数据库表中增加一个版本字段来实现。当更新库存时，除了减少库存数量，还将版本号加一。如果在更新的过程中版本号发生变化，说明有其他线程已经修改了这条记录，当前的操作将会失败。

代码示例：
@Transactional
public boolean reduceStockWithOptimisticLock(Product product, int quantity) {
    int version = product.getVersion();
    int result = productRepository.reduceStock(product.getId(), quantity, version);
    if (result == 0) {
        // 失败处理，例如重试或返回错误
        return false;
    } else {
        // 成功处理
        return true;
    }
}

4.1.2. 悲观锁

悲观锁是通过数据库的行锁或表锁来直接防止数据在事务中被其他事务修改。在高并发的场景下，可以通过SELECT FOR UPDATE语句将库存行锁定，这样在事务完成之前，其他事务就无法读取或修改这个库存行。

代码示例：
@Transactional
public boolean reduceStockWithPessimisticLock(Product product, int quantity) {
    // 锁定库存记录
    product = productRepository.findByIdForUpdate(product.getId());
    if (product.getStock() >= quantity) {
        product.setStock(product.getStock() - quantity);
        productRepository.save(product);
        return true;
    }
    return false;
}

4.1.3. 数据库事务隔离级别

设置合适的隔离级别可以防止多种并发问题。例如，可重复读（REPEATABLE READ）可以预防不可重复读的问题，串行化（SERIALIZABLE）可以提供最高级别的隔离。但是隔离级别越高，系统的并发能力可能越低。

4.2. 应用层面的优化

在应用层面，为了应对高并发导致的库存扣减问题，我们可以采取一系列的措施来优化系统的性能和稳定性。

4.2.1. 内存队列

内存队列是处理高并发请求的有效手段。在秒杀系统中，可以通过以下步骤使用内存队列来缓冲请求，从而解决超卖问题：

用户发起购买请求，系统首先将请求发送到消息队列，而不是直接操作数据库。
消息队列有序地处理这些请求，保证了处理顺序和速率。
后端服务消费队列中的消息，并进行库存扣减操作。

使用内存队列，核心的难点在于如何确保消息的顺序及时性以及消费的可靠性，避免消息丢失或重复消费。

代码示例：
public void onMessageReceived(ProductRequest request) {
    // 处理队列中的库存扣减请求
    productQueueService.processRequest(request);
}

4.2.2. 异步处理

在用户的购买请求中，不是所有的步骤都需要即时完成。例如，库存扣减可以在用户得到下单成功的反馈后，由后台系统异步处理。

异步响应：用户请求可以得到即时响应，提升用户体验。
后台处理：实际的库存扣减操作在后台异步完成，减轻前端服务器压力。

业务逻辑的异步处理可以利用Java的Future、CompletableFuture或是Spring框架的@Async注解。

4.2.3. 写入合并

在高并发场景下，对同一个商品进行库存扣减的请求可能会几乎同时到达，我们可以通过“写入合并”（coalescing writes）来优化这个过程：

请求合并：在一定时间窗口内，将对同一商品的扣减请求合并为一次请求。
批量处理：在后台系统中批量处理合并后的请求，减少对数据库的写入操作。

代码示例：
public void batchReduceStock(Map<Product, Integer> productList) {
    // 合并后的库存扣减Map，合并同一商品的扣减数量
    productList.forEach((product, quantity) -> {
        // 在数据库中批量扣减
        productRepository.reduceStock(product.getId(), quantity);
    });
}

4.2.4. 分布式缓存

使用分布式缓存可以显著提升系统的读取性能，同时减少数据库的压力。在秒杀系统中，可以将库存数据缓存在Redis这样的内存数据库中，这样的读取操作就可以快速响应，同时写入操作也可以通过队列异步处理，保持库存计数的准确性。

缓存使用示例：
public int getStockFromCache(int productId) {
    // 从缓存中获取库存信息
    return cacheService.getStock(productId);
}

public void reduceStockInCache(int productId, int quantity) {
    // 异步扣减缓存中的库存
    cacheService.reduceStock(productId, quantity);
}

4.2.5. 限流策略

限流是确保系统稳定性的常见策略。通过设置一个合理的阈值，限制系统处理请求的速率。这样就可以防止在瞬时大流量之下，系统过载崩溃的风险。

固定窗口限流：系统在固定时间窗口允许固定数量的请求通过。
滑动窗口限流：和固定窗口类似，但窗口是动态滑动的，提供更平滑的请求处理速度。
令牌桶限流：系统以一定的速率生成令牌，每个请求消耗一个令牌，这允许了短期的突发流量。

限流实现示例：
public boolean tryAcquire() {
    // 从令牌桶尝试获取令牌
    return rateLimiter.acquire();
}

通过上述的应用层面的优化措施，可以从多个角度出发降低高并发对系统稳定性和数据一致性的影响。在设计高并发秒杀系统时，这些策略往往会根据具体的业务场景和技术堆栈综合考虑。

5. 秒杀系统如何扣减库存?

库存扣减策略是秒杀系统中至关重要的环节。一个良好的策略能够最小化库存超卖的风险，并能在保证用户体验的同时维持系统的高性能与稳定性。

5.1. 秒杀场景分析

在秒杀场景中，所有的请求几乎在同一时间集中到服务器，这就造成了瞬时的巨大压力。为了应对这种情况，系统需要能够快速准确地完成请求响应，及时扣减库存，并立即给用户反馈。

5.2. 库存扣减具体方案

在设计库存扣减策略时，需要综合考虑系统架构、库存管理、用户体验等多个方面。

5.2.1. 系统架构设计

系统架构应当尽可能地做到高可用、高伸缩性，同时拥有良好的故障容错能力。常见的做法包括：

使用微服务架构：不同的服务独立部署，互不影响，易于横向扩展。
负载均衡：使用负载均衡器分配请求，优化资源使用，防止单点压力。
熔断机制：当服务不可用时，能够及时熔断，避免雪崩效应。

5.2.2. 代码实现与演示

对于库存扣减的实现，我们可以采用一种两阶段提交的方法结合分布式锁和消息队列：

第一阶段 - 预扣减库存：在分布式缓存如Redis中预扣减库存，如果扣减成功，将扣减信息发送到消息队列，并给用户返回“下单成功”的提示。
第二阶段 - 确认扣减库存：后台服务监听消息队列，消费预扣减的信息，然后进行数据库扣减操作，完成订单的最终确认。

代码示例：
public class StockService {

    // 第一阶段：预扣减库存
    public boolean preDeductStock(int productId, int quantity) {
        Long stockLeft = redisTemplate.opsForValue().decrement("stock:" + productId, quantity);
        if (stockLeft != null && stockLeft >= 0) {
            // 发送扣减消息到消息队列
            queueService.sendMessage(new StockDeductMessage(productId, quantity));
            return true;
        }
        // 库存不足
        return false;
    }

    // 第二阶段：确认扣减库存
    public void confirmDeductStock(StockDeductMessage message) {
        // 在数据库中扣减库存
        productRepository.deductStock(message.getProductId(), message.getQuantity());
    }
}

public class QueueService {

    // 消息队列的处理函数
    public void processMessage(StockDeductMessage message) {
        // 调用库存服务扣减库存
        stockService.confirmDeductStock(message);
    }
}