性能对比:各种锁方案的性能对比

回顾:我们学到了什么?📚

前两节我们学习了两种数据库锁方案:

悲观锁(3.1 节)在读的时候就抢锁:先 SELECT ... FOR UPDATE 把库存行锁住,再判断、再扣减。别的请求必须排队等锁释放。它的优点是绝对不会超卖,缺点是同一时刻只有一个请求能干活——100 个连接就是 100 TPS。

乐观锁(3.2 节)改成写的时候再校验:先无锁地读出库存和版本号,扣减时把版本号作为条件一起带上(WHERE id = ? AND version = ?),由数据库判断有没有被别人改过。冲突了就重试。它把”排队等锁”换成了”撞了再来一次”,吞吐明显更高,但在高冲突下重试次数会暴涨。

两者的共同点是都把并发写压到了数据库这一层。这一节要回答的是:这个代价到底有多大?以及——它和秒杀需要的量级差多少?

实战性能测试 🧪

让我们用真实数据来对比性能。

测试环境

为了让两种锁的对比有意义,测试必须只改变一个变量:同一台机器、同一份数据、同一个压测脚本,只替换”扣库存的那一条语句”。

项目配置
数据库MySQL 8.0,InnoDB 缓冲池 4G,innodb_buffer_pool_size=4G
服务器4 核 8G(压测机与数据库分离,同机房)
连接池HikariCP,100 个连接,超时 3s
压测端4 台压测机,每台 50 个线程,共 200 并发
商品单商品 100 件库存,product 表 10 万行、orders 表 100 万行
网络万兆网卡,同机房 RTT < 1ms
事务隔离级别READ COMMITTED(默认)

两个被测实现,差别只在核心语句:

def deduct_pessimistic(conn, product_id, qty):
    """悲观锁:读的时候就把行锁住"""
    conn.autocommit = False
    cur = conn.cursor()
    cur.execute("SELECT stock FROM product WHERE id=%s FOR UPDATE", (product_id,))
    stock = cur.fetchone()[0]
    if stock < qty:
        conn.rollback()
        return False
    cur.execute("UPDATE product SET stock=stock-%s WHERE id=%s", (qty, product_id))
    conn.commit()
    return True


def deduct_optimistic(conn, product_id, qty):
    """乐观锁:先读,提交时用版本号做条件"""
    cur = conn.cursor()
    cur.execute("SELECT stock, version FROM product WHERE id=%s", (product_id,))
    stock, version = cur.fetchone()
    if stock < qty:
        return False
    cur.execute(
        "UPDATE product SET stock=stock-%s, version=version+1 WHERE id=%s AND version=%s",
        (qty, product_id, version),
    )
    return cur.rowcount == 1      # 影响行数为 0 → 冲突

测量指标:总耗时、平均响应时间、峰值 QPS、成功率,以及乐观锁的冲突率(更新影响行数为 0 的占比)。

读结果时要注意两点:

  1. 成功率只有 2% 不是 bug——5000 个请求抢 100 件库存,成功 100 件是正确结果,剩下 4900 个理应失败。
  2. 乐观锁在超高并发下”总耗时更短”是因为大部分请求在冲突后直接放弃了,而不是因为它真的处理了更多请求。判断一个方案能不能用,要看 QPS 和它要支撑的目标之间的差距,而不是看总耗时。

这些数字来自单机测试,目的是比较不同锁方案之间的相对关系,不代表生产容量。 生产环境还要叠加序列化、业务逻辑、GC、网络和主从复制的影响,实测值通常比这里再低 30%~50%。

测试结果

🔬 测试环境配置:
数据库:MySQL 8.0
服务器:4核8G
连接池:100个连接

测试场景:
  低并发: 100请求 / 100库存
  中并发: 500请求 / 100库存
  高并发: 1000请求 / 100库存
  超高并发: 5000请求 / 100库存

================================================================================
📊 性能对比测试结果
================================================================================

🎯 场景:低并发 (100请求 / 100库存)
--------------------------------------------------------------------------------

指标                         悲观锁                 乐观锁              差异
--------------------------------------------------------------------------------
总耗时(ms)                    1000.00                200.00            5.00x
平均响应(ms)                    10.00                  2.00            5.00x
QPS                             100                   500            5.00x
成功率                         100.0%                100.0%                -
冲突率                             -                   0.0%                -

性能评估:
  ❌ 乐观锁:不满足秒杀需求(QPS: 500 < 500,000)

🎯 场景:超高并发 (5000请求 / 100库存)
--------------------------------------------------------------------------------

指标                         悲观锁                 乐观锁              差异
--------------------------------------------------------------------------------
总耗时(ms)                   50000.00              19000.00            2.63x
平均响应(ms)                    10.00                  3.80            2.63x
QPS                             100                   263            2.63x
成功率                           2.0%                  2.0%                -
冲突率                             -                  98.0%                -

性能评估:
  ❌ 乐观锁:不满足秒杀需求(QPS: 263 < 500,000)

性能瓶颈分析 🔍

为什么数据库锁方案性能不够?

锁方案选择指南 📖

根据不同的场景,选择不同的方案:

选型的出发点不是”哪个方案更先进”,而是先问清楚这次写入需要多强的保证。

场景特征推荐方案原因
并发量低(< 1000 QPS)、且绝对不能出错(资金、库存台账)悲观锁强一致由数据库保证,业务代码不必写重试逻辑,心智负担最小
并发量中等(1000-20000 QPS)、允许偶尔冲突后重试乐观锁(版本号)冲突率可控,吞吐比悲观锁高一个量级,重试逻辑简单
秒杀、抢购等瞬时高并发场景Redis 原子操作 + 异步落库把热点从数据库挪走,避免为无效请求付出并发写代价
只需要计数、不需要严格精确(如浏览量、热度分)Redis 原子自增允许最终一致,用计数器换吞吐
多商品同时扣减(如批量下单、批量退款)乐观锁 + 按主键升序处理避免多行交叉更新造成死锁

还有两条经验性规则:

  1. 先问”失败的代价是什么”。 失败代价高(少卖、超卖、资损)且并发量不大,就用悲观锁把正确性交给数据库;失败代价可容忍(展示不准、统计偏差),就用更快的方案。
  2. 先问”有效写有多少”。 如果有效写只有 100 次而并发请求有 50 万次,那么无论选哪种锁,都是在用 50 万次并发写的代价去换 100 次写入——这时答案不是”选一把更好的锁”,而是”把无效请求挡在数据库之外”。这正是第 4 章 Redis 方案要解决的问题。

数据对比大表 📊

性能对比总表

方案QPS延迟一致性复杂度成本适用场景
悲观锁1,000-5,00010-100ms强一致⭐💰后台管理
乐观锁5,000-20,0002-20ms最终一致⭐⭐💰普通电商
乐观锁+缓存10,000-50,0001-10ms最终一致⭐⭐⭐💰💰促销活动
Redis原子操作100,000-500,0000.1-1ms最终一致⭐⭐⭐⭐💰💰💰秒杀活动
完整秒杀架构500,000+10-100ms最终一致⭐⭐⭐⭐⭐💰💰💰💰超级秒杀

成本对比

同样为了支撑 50 万 QPS,不同方案要付出多少资源。下面是量级估算(按 8C32G 云主机、月成本 ¥2000 折算):

方案达到 50 万 QPS 所需资源(估算)硬件成本一致性代价运维复杂度
悲观锁约 50 台 32C128G 主库💰💰💰💰💰无(强一致)低
乐观锁约 10 台 32C128G💰💰💰冲突重试、需补偿低
乐观锁 + 缓存约 4 台 32C128G💰💰缓存一致性问题中
Redis 原子操作6 节点 16C64G 集群💰💰需异步落库 + 对账中
完整秒杀架构6 节点 Redis + 3 Broker + 6 台 MySQL + 业务服务器💰💰💰最终一致高

换算过程其实很朴素:

悲观锁吞吐上限 ≈ 1 / 0.01s(单次持锁 10ms)= 100 TPS/连接
   → 100 个连接 ≈ 10,000 TPS
   → 50 万 TPS 需要 50 台数据库(还没算故障切换和主从)

乐观锁吞吐上限 ≈ 1 / 2ms(一次读 + 一次条件更新)= 500 TPS/连接
   → 100 个连接 ≈ 50,000 TPS
   → 50 万 TPS 需要 10 台数据库

Redis 单实例 ≈ 100,000 TPS
   → 50 万 TPS 需要 6 节点集群(3 主 3 从)

这张表的真正含义不是”Redis 便宜”,而是”并发写数据库的代价随并发线性增长”。

库存只有 100 件,却要支撑 50 万 QPS,本质上是在为 100 次有效写支付 50 万次并发写的成本。把无效请求挡在数据库之外,省下的不是几台机器,而是整个扩容故事——而且机器越多,MySQL 主从延迟、故障切换风险、运维成本还会一起上涨。

数据库方案Redis + 队列方案
硬件投入随流量增长线性增长基本不变(加机器只是加吞吐)
故障面主库挂了 = 全部不可写Redis 挂了可从 MySQL 重建
数据风险事务保证不丢内存易失,需要对账兜底
适用阶段早期、后台、库存充足秒杀、抢购、限量活动

总结:秒杀场景的困境与出路 🎯

先说困境:

需求:50 万 QPS
现实:数据库是最终事实来源,却只有 1000-5000 QPS

两难:
  只用数据库 → 性能不够,差 25~500 倍
  只用 Redis  → 不可靠,宕机丢数据、多副本不一致

这个困境的本质是:同一个系统里同时要求了两种互相冲突的能力。

  • “快速判断”要求数据在内存、无锁、可丢弃;
  • “准确记录”要求数据在磁盘、有事务、可审计。

出路不是二选一,而是把两件事拆给两个系统:

Redis 负责"快":内存、单线程原子操作、允许短暂不一致
      ↓  消息队列异步同步(削峰 + 可靠投递)
MySQL 负责"准":事务、条件更新、持久可审计
      ↓  定时对账收敛
两边最终一致

这个结构的代价是必须承认”存在不一致窗口”,并用三件事把风险堵住:

  1. Redis 侧原子扣减——不超卖(见 4.1 节)。
  2. MySQL 侧条件更新 WHERE stock >= ?——即使 Redis 出了错,货也发不出去(见 6.3 节第二道防线)。
  3. 定时对账 + 止损——两道防线都失效时,靠离线比对发现并止血(见 6.2 节)。

最后一句话:秒杀系统不是”用 Redis 替代 MySQL”,而是”用 Redis 承担高频判断,用 MySQL 承担最终记账”。凡是试图用单一存储解决全部问题的方案,都会在真实流量下崩掉。

想一想

问题 1:为什么数据库性能有上限?

提示:

  • 磁盘I/O速度
  • 网络延迟
  • 锁竞争
  • 连接数限制

问题 2:如何突破数据库的性能瓶颈?

提示:

  • 内存 vs 磁盘
  • 同步 vs 异步
  • 单机 vs 分布式
  • 强一致 vs 最终一致

问题 3:秒杀场景最看重什么?

提示:

  • 性能
  • 一致性(不超卖、不少卖)
  • 可用性
  • 成本

发现内容有问题?

告诉我们哪里需要改进。