高并发秒杀系统设计：基于 Redis + MySQL 的多级锁与两阶段库存扣减方案

在电商系统中，秒杀活动 是最具挑战性的场景之一。短时间内海量用户同时抢购有限库存的商品，极易引发 超卖、库存不一致、数据库压力过大 等问题。本文将详细介绍我在一个电商项目中为 库存服务（inventory_srv） 设计并实现的高并发秒杀系统，重点解决 数据一致性与高并发稳定性 问题。

该系统最终成功支撑了日均 10万+并发请求 的抢购场景，未发生一次超卖事故，具备极高的可靠性与可扩展性。

一、秒杀系统的挑战

1. 核心问题

2. 设计目标

• ✅ 零超卖：任何情况下都不能出现库存负数或超额发放
• ✅ 高性能：支持 10万+ QPS 的并发抢购
• ✅ 最终一致性：Redis 与 MySQL 库存数据保持一致
• ✅ 失败可回滚：业务失败时能自动归还预扣库存

二、整体架构设计

✅ 架构特点：

• Redis 分布式锁：商品级粒度锁定，防止并发冲突
• 两阶段库存扣减：预扣减 + 确认扣减，保障事务完整性
• 多级锁机制：Redis + MySQL 悲观/乐观锁协同工作
• 事务回滚机制：确保失败时库存准确归还

三、关键技术实现详解

1. 商品级分布式锁（Redsync + Redis）

为了避免多个服务实例同时操作同一商品库存，使用 Redis 分布式锁 实现商品级别的串行化访问。

使用 redsync 库实现：

import "github.com/go-redsync/redsync/v4"
import "github.com/go-redsync/redsync/v4/redis/goredis/v9"

// 初始化 Redsync
pool := goredis.NewPool(client) // client 是 *redis.Client
rs := redsync.New(pool)
mutex := rs.NewMutex("lock:goods:1001") // 商品 ID 为 1001

// 加锁
if err := mutex.Lock(); err != nil {
    return errors.New("抢购失败，请重试")
}
defer mutex.Unlock() // 自动释放

✅ 优势：

• 基于 Redis 的 SETNX 实现，性能高
• 支持自动过期，避免死锁
• redsync 提供了完善的容错和重试机制

2. 两阶段库存扣减流程

为了确保库存操作的原子性和可回滚性，采用 “预扣减 + 确认扣减” 的两阶段模型。

阶段一：预扣减（Freeze Phase）

func PreDeductStock(goodsID, count int) error {
    // 1. 获取分布式锁（已由上层保证）

    // 2. 检查可用库存 = 实际库存 - 已冻结库存
    available, err := getAvailableStock(goodsID)
    if err != nil || available < count {
        return errors.New("库存不足")
    }

    // 3. 冻结库存（Redis + MySQL 双写）
    err = freezeStockInRedis(goodsID, count)
    if err != nil {
        return err
    }

    err = freezeStockInMySQL(goodsID, count)
    if err != nil {
        // 回滚 Redis 冻结
        rollbackFreezeInRedis(goodsID, count)
        return err
    }

    return nil
}

✅ 关键点：

• freeze_stock 字段记录当前已锁定但未确认的库存
• Redis 和 MySQL 同时更新，保证最终一致性
• 若任一失败，立即回滚另一方

阶段二：确认扣减 or 回滚

✅ 场景 A：订单创建成功 → 确认扣减

func ConfirmDeduct(goodsID, count int) error {
    tx := db.Begin()

    var stock int
    var version int

    // 使用 MySQL 悲观锁锁定库存行
    tx.Set("gorm:query_option", "FOR UPDATE").
        Select("stock, version").
        First(&Inventory{}, "goods_id = ?", goodsID).
        Scan(&stock, &version)

    if stock < count {
        tx.Rollback()
        return errors.New("库存不足")
    }

    // 扣减实际库存，减去冻结库存
    result := tx.Model(&Inventory{}).
        Where("goods_id = ? AND version = ?", goodsID, version).
        Updates(map[string]interface{}{
            "stock":        gorm.Expr("stock - ?", count),
            "freeze_stock": gorm.Expr("freeze_stock - ?", count),
            "version":      version + 1,
        })

    if result.RowsAffected == 0 {
        tx.Rollback()
        return errors.New("库存更新失败")
    }

    tx.Commit()
    return nil
}

🔐 双重保障：

• FOR UPDATE：防止其他事务并发修改
• version 字段：乐观锁，防止 ABA 问题

❌ 场景 B：订单创建失败 → 回滚冻结库存

func RollbackFreeze(goodsID, count int) error {
    // 1. 释放 Redis 冻结库存
    _, err := redisClient.DecrBy(ctx, "stock:"+goodsID, int64(count)).Result()
    if err != nil {
        return err
    }

    // 2. MySQL 中减少冻结库存
    result := db.Model(&Inventory{}).
        Where("goods_id = ?", goodsID).
        Update("freeze_stock", gorm.Expr("freeze_stock - ?", count))

    return result.Error
}

✅ 自动回滚机制：

• 可通过 消息队列延迟任务 或 定时扫描未支付订单 触发回滚
• 避免用户放弃支付后库存长期被占用

3. 多级锁协同工作机制

✅ 协同流程：

1. 先通过 Redis 锁保证只有一个请求进入处理流程
2. 在事务中使用 FOR UPDATE 锁定库存记录
3. 更新时校验 version，确保数据未被修改

四、数据一致性保障策略

1. Redis 与 MySQL 双写一致性

• 写操作：先写 MySQL，再写 Redis（或同时写，设置短 TTL）
• 读操作：优先读 Redis，失败降级读 MySQL
• 异步补偿：通过定时任务校对 Redis 与 MySQL 库存差异

2. 异常情况处理

五、性能优化与压测结果

1. 性能优化措施

• ✅ Redis 缓存可用库存：避免频繁查询数据库
• ✅ 本地缓存热点商品信息：减少 RPC 调用
• ✅ 批量提交事务：降低数据库 I/O 开销
• ✅ 连接池优化：gRPC、MySQL、Redis 连接复用

2. 压测数据（单商品，初始库存 100）

✅ 实际线上运行日均 10万+ 并发抢购，系统稳定，无超卖。

六、总结与最佳实践

✅ 本方案的核心优势：

1. 零超卖保障：通过分布式锁 + 两阶段扣减 + 多级锁机制，彻底杜绝超卖。
2. 高并发支持：Redis 锁 + 缓存 + 异步回滚，支撑大流量冲击。
3. 事务完整性：预扣减机制确保业务失败后库存可准确归还。
4. 最终一致性：Redis 与 MySQL 数据通过双写+补偿机制保持一致。

📌 最佳实践建议：

• 幂等性设计：每个抢购请求应具备唯一 ID，防止重复提交
• 限流保护：结合 Sentinel 对秒杀接口进行 QPS 限制
• 降级预案：当系统压力过大时，可关闭非核心功能
• 监控告警：实时监控库存、锁竞争、事务回滚等关键指标

七、结语

本文详细阐述了一个高并发秒杀系统的完整设计与实现路径。通过 Redis 分布式锁、MySQL 悲观/乐观锁、两阶段库存扣减、事务回滚机制 的有机结合，我们成功构建了一个既高效又可靠的库存控制系统。

这套方案不仅适用于秒杀场景，也可推广至 优惠券领取、抽奖活动、限量发售 等需要强一致性和高并发处理能力的业务中。

希望这篇文章能帮助你深入理解高并发系统的设计精髓，在未来的项目中游刃有余地应对各种挑战。