性能对比:各种锁方案的性能对比
前两节我们学习了两种数据库锁方案:
悲观锁(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 的占比)。
读结果时要注意两点:
- 成功率只有 2% 不是 bug——5000 个请求抢 100 件库存,成功 100 件是正确结果,剩下 4900 个理应失败。
- 乐观锁在超高并发下”总耗时更短”是因为大部分请求在冲突后直接放弃了,而不是因为它真的处理了更多请求。判断一个方案能不能用,要看 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 原子自增 | 允许最终一致,用计数器换吞吐 |
| 多商品同时扣减(如批量下单、批量退款) | 乐观锁 + 按主键升序处理 | 避免多行交叉更新造成死锁 |
还有两条经验性规则:
- 先问”失败的代价是什么”。 失败代价高(少卖、超卖、资损)且并发量不大,就用悲观锁把正确性交给数据库;失败代价可容忍(展示不准、统计偏差),就用更快的方案。
- 先问”有效写有多少”。 如果有效写只有 100 次而并发请求有 50 万次,那么无论选哪种锁,都是在用 50 万次并发写的代价去换 100 次写入——这时答案不是”选一把更好的锁”,而是”把无效请求挡在数据库之外”。这正是第 4 章 Redis 方案要解决的问题。
性能对比总表
| 方案 | QPS | 延迟 | 一致性 | 复杂度 | 成本 | 适用场景 |
|---|---|---|---|---|---|---|
| 悲观锁 | 1,000-5,000 | 10-100ms | 强一致 | ⭐ | 💰 | 后台管理 |
| 乐观锁 | 5,000-20,000 | 2-20ms | 最终一致 | ⭐⭐ | 💰 | 普通电商 |
| 乐观锁+缓存 | 10,000-50,000 | 1-10ms | 最终一致 | ⭐⭐⭐ | 💰💰 | 促销活动 |
| Redis原子操作 | 100,000-500,000 | 0.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 负责"准":事务、条件更新、持久可审计
↓ 定时对账收敛
两边最终一致
这个结构的代价是必须承认”存在不一致窗口”,并用三件事把风险堵住:
- Redis 侧原子扣减——不超卖(见 4.1 节)。
- MySQL 侧条件更新
WHERE stock >= ?——即使 Redis 出了错,货也发不出去(见 6.3 节第二道防线)。 - 定时对账 + 止损——两道防线都失效时,靠离线比对发现并止血(见 6.2 节)。
最后一句话:秒杀系统不是”用 Redis 替代 MySQL”,而是”用 Redis 承担高频判断,用 MySQL 承担最终记账”。凡是试图用单一存储解决全部问题的方案,都会在真实流量下崩掉。
问题 1:为什么数据库性能有上限?
提示:
- 磁盘I/O速度
- 网络延迟
- 锁竞争
- 连接数限制
问题 2:如何突破数据库的性能瓶颈?
提示:
- 内存 vs 磁盘
- 同步 vs 异步
- 单机 vs 分布式
- 强一致 vs 最终一致
问题 3:秒杀场景最看重什么?
提示:
- 性能
- 一致性(不超卖、不少卖)
- 可用性
- 成本
发现内容有问题?
告诉我们哪里需要改进。
