实战商品订单秒杀设计实现

实战商品订单秒杀设计实现

前言

在高并发秒杀、抢购等场景下，订单系统极易出现"超卖"问题，即实际售出的商品数量超过库存。本文将详细介绍超卖的成因、常见解决方案，重点讲解如何通过Redis实现高效、可靠的防超卖机制，并给出实用代码和优化建议。

1. 超卖问题背景

1.1 什么是超卖

超卖指的是在并发环境下，多个用户同时下单，导致实际售出商品数量超过库存。例如，库存只有10件，但最终卖出了12件。

1.2 超卖产生的原因

• 多线程/多进程并发下，库存判断和扣减不是原子操作
• 数据库操作未加锁或锁粒度过大，影响性能
• 分布式部署下，节点间状态不一致

2. 常见防超卖方案

1. 数据库加锁：如悲观锁（for update）、乐观锁（版本号/时间戳）
2. 队列削峰：下单请求入队，单线程消费
3. 缓存预扣减：用Redis等缓存中间件做库存扣减

其中，基于Redis的方案因高性能、易扩展、支持分布式而被广泛采用。

3. 基于Redis的防超卖原理

3.1 Redis的优势

• 单线程模型，天然支持原子操作
• 支持高并发、低延迟
• 提供分布式锁、Lua脚本等机制

3.2 实现思路

• 库存预先写入Redis
• 用户下单时，先在Redis中原子扣减库存
• 扣减成功再写入订单数据库
• 扣减失败（库存不足）则下单失败

4. Redis防超卖实现方式

4.1 基础实现：decr原子扣减

// 初始化库存
redisTemplate.opsForValue().set("product_stock:1001", 10);

// 下单接口伪代码
public String placeOrder(Long productId) {
    Long stock = redisTemplate.opsForValue().decrement("product_stock:" + productId);
    if (stock < 0) {
        // 库存不足，回滚
        redisTemplate.opsForValue().increment("product_stock:" + productId);
        return "库存不足，抢购失败";
    }
    // 生成订单，写入数据库
    // ...
    return "下单成功";
}

优点：操作简单，性能高。

缺点：存在并发下"库存回滚"不及时、订单与库存不一致等问题。

4.2 分布式锁方案

为保证订单和库存操作的一致性，可引入Redis分布式锁：

public String placeOrderWithLock(Long productId) {
    String lockKey = "lock:product:" + productId;
    String clientId = UUID.randomUUID().toString();
    Boolean locked = redisTemplate.opsForValue().setIfAbsent(lockKey, clientId, 5, TimeUnit.SECONDS);
    if (!locked) {
        return "系统繁忙，请稍后重试";
    }
    try {
        Long stock = redisTemplate.opsForValue().get("product_stock:" + productId);
        if (stock == null || stock <= 0) {
            return "库存不足";
        }
        redisTemplate.opsForValue().decrement("product_stock:" + productId);
        // 生成订单
        // ...
        return "下单成功";
    } finally {
        // 释放锁（需确保只释放自己加的锁）
        if (clientId.equals(redisTemplate.opsForValue().get(lockKey))) {
            redisTemplate.delete(lockKey);
        }
    }
}

注意：分布式锁要保证"加锁、业务、解锁"三步的原子性，推荐使用Redisson等成熟组件。

4.3 Lua脚本实现库存扣减与下单原子性

利用Redis的Lua脚本，可以将库存判断和扣减、订单写入等操作合并为原子操作：

// Lua脚本内容
String luaScript = """
    local stock = redis.call('get', KEYS[1])
    if (tonumber(stock) <= 0) then
        return -1
    end
    redis.call('decr', KEYS[1])
    return 1
""";

// Java调用
DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>(luaScript, Long.class);
Long result = redisTemplate.execute(redisScript, Collections.singletonList("product_stock:1001"));
if (result == -1) {
    return "库存不足";
} else {
    // 生成订单
    // ...
    return "下单成功";
}

优点：彻底避免并发下的库存超卖和回滚问题。

5. 常见坑与优化建议

5.1 脚本原子性

• Lua脚本在Redis中执行，保证原子性，但脚本过大影响性能

5.2 锁失效与死锁

• 分布式锁要设置超时时间，避免死锁
• 解锁时需校验锁的归属

5.3 订单与库存一致性

• Redis扣减成功但订单写库失败，需补偿机制（如异步队列、定时任务修正）

5.4 高并发下的限流与削峰

• 可结合消息队列MQ，先入队再异步扣减库存

5.5 防止重复下单

• 可用Redis的setnx或布隆过滤器做幂等校验

6. 实际案例

6.1 秒杀系统架构

• 用户请求 -> Nginx负载均衡 -> 应用服务 -> Redis库存预扣减 -> MQ异步下单 -> 数据库落单

6.2 代码片段（Spring Boot + Redis）

@RestController
public class SeckillController {
    @Autowired
    private StringRedisTemplate redisTemplate;

    @PostMapping("/seckill")
    public String seckill(@RequestParam Long productId) {
        String luaScript = """
            local stock = redis.call('get', KEYS[1])
            if (tonumber(stock) <= 0) then
                return -1
            end
            redis.call('decr', KEYS[1])
            return 1
        """;
        DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>(luaScript, Long.class);
        Long result = redisTemplate.execute(redisScript, Collections.singletonList("product_stock:" + productId));
        if (result == -1) {
            return "库存不足";
        }
        // 发送MQ消息异步创建订单
        // ...
        return "抢购成功，订单生成中";
    }
}

7. 总结

通过Redis的原子操作、分布式锁和Lua脚本，可以高效、可靠地实现订单防超卖。实际生产中建议结合消息队列、幂等校验、补偿机制等手段，进一步提升系统的健壮性和可扩展性。

---

本文系统介绍了超卖问题的成因、Redis防超卖的多种实现方式及优化建议，适合电商、秒杀等高并发场景下的开发者参考。