乐观锁:使用版本号实现乐观锁
上一节我们学习了悲观锁,它有一个致命问题:
悲观锁性能测试结果:
- 1000 QPS:响应时间 100ms
- 5000 QPS:响应时间 500ms
- 10000 QPS:响应时间 1000ms+
- 秒杀场景需要 500000 QPS ❌ 完全不够用!
问题根源:
所有请求排队等待锁 🔒
线程A ━━━━━━━━━━━━━━┫
线程B ⏳ ━━━━━━━━━━━━━━┫
线程C ⏳ ━━━━━━━━━━━━━━┫
线程D ⏳ ━━━━━━━━━━━━━━┫
每个请求必须等前一个请求完全完成才能开始
新的思路:
- 悲观锁:假设一定会冲突,先加锁再操作
- 乐观锁:假设大概率不冲突,先操作,冲突时重试
一句话概括:乐观锁假设冲突很少发生,所以不预先阻止冲突,而是先操作,检测到冲突再重做。
悲观锁和乐观锁的差别,本质上是”冲突的成本付在哪里”:
- 悲观锁把成本付在等待上:后来的请求必须等前面的做完,一个都跑不掉。
- 乐观锁把成本付在失败上:所有请求一起跑,只有真正撞车的那些才需要重试。
当冲突很少时,后者几乎不花钱;当冲突很多时,两种方式都会崩——只不过悲观锁是”全崩”,乐观锁是”先甜后苦”。
生活中的乐观锁例子
乐观锁在现实里非常常见,只是没人这么叫它。
例一:在线选座(最贴切的一个)
你打开航司 App 选座,屏幕上 32 号显示为空 ✅
你犹豫了几秒,隔壁老王也看上了 32 号
你点"确认"——系统不会因为你看得早就让给你,而是先校验:
"32 号现在还是我刚才看到的状态吗?"
├─ 是 → 座位归你 ✅
└─ 不是 → "座位已被选走",你重新选一个
关键在于:你从头到尾没有被”锁住”。你读了一遍(可能读了很多遍),提交时校验一次,对不上就重来。这正是 CAS(Compare-And-Swap)的字面含义——比较并交换。
例二:超市收银
收银员扫完商品,小票上写着”结账前请核对商品数量”。你发现少了一罐可乐,收银员会重新扫码,而不是让你在货架上把所有商品再数一遍。
这就是乐观锁的思路:先干,把校验点放在最后。
例三:程序里的 CAS
Java 里 AtomicInteger.compareAndSet(100, 99) 的语义就是”如果当前值还是 100,就改成 99,成功返回 true”——把”读、判断、写”三步压成一步,中间不留缝隙。
和悲观锁的生活对照:
| 悲观锁 | 乐观锁 | |
|---|---|---|
| 生活类比 | 银行柜台取款:柜员把存折收走,你只能排队等 | 手机 App 选座:先挑,提交时校验,被抢了就重来 |
| 谁被阻塞 | 后面所有人 | 只有冲突的那一个请求 |
| 冲突的表现 | 等待 | 失败 + 重试 |
为什么叫”乐观”:因为它乐观地认为冲突是少数情况。这个假设成立时,它几乎不产生额外开销;假设不成立时(秒杀就是典型的反例),它会退化得很惨。
在数据库层面实现乐观锁,主流做法有两条路:用版本号做条件更新,以及用 CAS 语义包装原子操作。两者本质相同——都是”比较一个读到的旧值,条件不成立就说明数据被改过”。
方案1:版本号机制
数据设计要点
- 这是一次表结构演进:随着业务能力增加,把新状态、新时间点或新归属关系补进数据模型。
- 查询目标是快速定位状态、任务或资源,避免在关键路径上做大范围扫描。
完整方案落地:
先在表上留一个版本号字段:
ALTER TABLE product
ADD COLUMN version INT NOT NULL DEFAULT 0 COMMENT '乐观锁版本号';
然后按”读 → 判断 → 带条件更新”三步走:
-- 第一步:读出当前数据和版本号(不加锁,普通查询)
SELECT id, stock, version
FROM product
WHERE id = 1;
-- 假设读到:stock = 1, version = 7
-- 第二步:判断和更新合成一条语句
UPDATE product
SET stock = stock - 1,
version = version + 1
WHERE id = 1
AND version = 7 -- 版本号没变,说明我读到的还是最新数据
AND stock >= 1; -- 库存够
怎么判断成功还是失败:看影响行数。
| 影响行数 | 含义 | 处理 |
|---|---|---|
| 1 | 扣减成功 | 继续下单 |
| 0 | 版本号已被改过(冲突) | 重新读取后重试 |
| 0 | 库存不足 | 直接失败,返回”已售罄” |
注意:两种情况的影响行数都是 0,需要额外区分到底是”冲突”还是”库存不足”——所以实际实现里会先在应用层判断 stock >= 1,把”库存不足”这一种提前挡掉。
并发时的实际过程:
10 个请求同时抢最后 1 件:
请求A: SELECT → stock=1, version=7
请求B: SELECT → stock=1, version=7 ← 和 A 读到同一份
请求C: SELECT → stock=1, version=7
请求A: UPDATE ... WHERE version=7 AND stock>=1 → 影响 1 行 ✅
(此刻 stock=0, version=8)
请求B: UPDATE ... WHERE version=7 AND stock>=1 → 影响 0 行 ❌
(version 已经不是 7 了)
请求C: UPDATE ... WHERE version=7 AND stock>=1 → 影响 0 行 ❌
两个条件各管一件事,不能互相替代:
version = ?解决的是并发写覆盖:“我基于旧数据做的修改会不会踩掉别人的修改”。stock >= 1解决的是业务语义:“库存到底够不够”。它和版本号无关——哪怕世界上只有一个请求在扣,库存不足时也必须扣失败。
两个都保留,才既安全又正确。少了版本号会丢更新,少了 stock >= 1 会把库存扣成负数。
版本号是单调递增的,这一点在后面的 ABA 问题里会变得很重要。
方案2:CAS(Compare And Swap)
CAS 是乐观锁的通用形式:一条原子指令,同时完成”比较”和”交换”。
CAS(expected, new):
原子地:
如果 内存中的值 == expected:
把它改成 new,返回成功
否则:
什么都不做,返回失败
比较和交换之间不能有任何缝隙——这正是它比”先读后写”强的地方。
JVM 里的标准形态:
AtomicInteger stock = new AtomicInteger(100);
// 只有当当前值还是 100 时才改成 99
boolean ok = stock.compareAndSet(100, 99);
Redis 里的等价实现:
-- 库存 key 现在的值必须等于 ARGV[1],才能改成 ARGV[2]
local current = redis.call('GET', KEYS[1])
if current == ARGV[1] then
redis.call('SET', KEYS[1], ARGV[2])
return 1
end
return 0
数据库里其实没有原生的 CAS——UPDATE ... WHERE version = ? 已经是数据库能给出的最接近的东西了。所以三种实现的定位是:
| 实现 | 典型 API | 作用域 | 适用 |
|---|---|---|---|
| 版本号条件更新 | UPDATE ... WHERE version = ? | 跨进程、持久化 | 数据库表,秒杀落库 |
| 原子类 CAS | AtomicInteger.compareAndSet | 单个 JVM 内存 | 本地计数器、内存状态 |
| Redis Lua 比较 | GET + 比较 + SET 合成脚本 | Redis 实例内 | 内存中的库存、分布式计数 |
版本号和 CAS 的关系:版本号其实是 CAS 的一种”增强版”实现——CAS 比较的是原值(值从 A 变 B 又变 A 就感知不到),版本号比较的是历史(单调递增,永不回退)。这就是版本号能规避 ABA 的原因。
它们的共同点:都不预先加锁,都靠”事后发现冲突”来保证正确性。
测试结果对比:
============================================================
开始对比测试:100个用户抢购
============================================================
🔒 测试悲观锁...
悲观锁结果:
成功:10/100
耗时:1234.56ms
平均响应:12.35ms
🔓 测试乐观锁...
乐观锁结果:
成功:10/100
耗时:456.78ms
平均响应:4.57ms
============================================================
性能对比:
============================================================
悲观锁:耗时 1234ms
乐观锁:耗时 456ms
性能提升:2.7倍 🚀
回到刚才的对比测试:同样的 100 个用户,悲观锁耗时 1234ms,乐观锁只用了 456ms,快了 2.7 倍。
这 2.7 倍是从哪来的?把一次请求的耗时拆开看就清楚了。
为什么乐观锁更快?
第一步:拆解单次请求的耗时构成
悲观锁的一次请求:
├─ 等待行锁 ← 可能很长,和并发数成正比
├─ 执行业务逻辑 ← 固定成本,很短
├─ 提交事务(落盘) ← 固定成本,毫秒级
└─ 释放锁(随提交) ← 固定成本
乐观锁的一次请求:
├─ 读数据 ← 并行执行,不互相等待
├─ 条件更新 ← 固定成本
└─ 冲突了才重试 ← 只有少数请求付这笔钱
第二步:逐项对比
| 开销项 | 悲观锁 | 乐观锁 |
|---|---|---|
| 获取锁 | 需要,且可能阻塞 | 不需要 |
| 释放锁 | 需要,随事务提交 | 不需要 |
| 冲突处理 | 排队等待 | 失败重试 |
| 事务提交 | 每次都提交 | 只有成功的那次提交 |
| 并发度 | 同一行上 = 1 | 同一行上 = N |
第三步:找到关键差异
- 悲观锁的开销是”必付”的。 即使完全没有冲突,每个请求也要付出加锁、解锁、事务提交的代价。乐观锁在无冲突时只付出一次普通 UPDATE。
- 悲观锁把并发变成串行。 100 个请求抢同一行,就是 100 次串行事务,耗时约等于 100 乘以单次事务时间。乐观锁是 100 个请求并行跑,总耗时约等于 1 次请求时间加上少量重试。
- 乐观锁的代价只由少数人承担。 100 个请求抢 10 件库存,只有真正撞车的(大概 10 个)需要重试,其余 90 个一次就成功。
必须说清楚的边界:乐观锁更快的前提是冲突率低。如果冲突率高到几乎每次都失败,重试会变成雪崩——每个失败请求都在重试,重试又制造新的冲突,请求数被放大几千倍,数据库反而比悲观锁更惨。
所以那句”乐观锁比悲观锁快”是有条件的:冲突率决定它值不值得用,而不是无条件的优劣。
下面两张表是乐观锁的标准优缺点。但真正决定能不能用好它的,是两件容易被跳过的事:冲突率决定收益,版本号机制决定正确性。下面重点讲这两件。
优点 ✅
| 优点 | 说明 | 适用场景 |
|---|---|---|
| 并发性能高 | 读取不加锁,并发度高 | 读多写少 |
| 无死锁 | 不需要获取锁,不会死锁 | 复杂事务 |
| 实现简单 | 只需添加版本号字段 | 快速开发 |
| 数据库压力小 | 不需要维护锁 | 高并发 |
缺点 ❌
| 缺点 | 说明 | 影响 |
|---|---|---|
| ABA问题 | 值从A改成B又改成A,无法感知 | 部分场景 |
| 冲突重试 | 高冲突时大量重试,性能下降 | 秒杀场景严重 |
| 用户体验 | 冲突时需要重试,可能失败 | 用户感知 |
| 业务侵入 | 需要处理重试逻辑 | 代码复杂度 |
ABA问题详解
ABA 是所有基于”比较值”的 CAS 都有的经典问题。
问题定义
CAS 比较的是值本身,而不是这个值的变化历史。如果一个值从 A 变成 B,又从 B 变回 A,CAS 看到的还是”A”,它完全无法感知中间发生过什么。
时间轴:
初始值:A
T1: 读到 A
T2: 读到 A
T1: CAS(A → B) ✅ 成功
T2: 把值改回 A (或者别的线程改的)
T1: 读到 B,准备 CAS(B → C)
此时如果 T1 比较的是"当前值 == A",它会认为"没人动过" ❌
经典的无锁栈例子
初始栈: head = A, A.next = B
T1: 读 head = A,记下 A.next = B,准备 CAS(head, A, C)
T2: pop A → head = B
T3: push A → head = A ← 值又变回 A 了!
T1: CAS(head, A, C) 成功 → head = C, C.next = A.next = B
栈变成 C → B
但 T2 已经消费过那个 A,T1 又把它用了一次 → A 被重复使用,B 也被算错了
在库存场景里会是什么样?
纯扣减的库存是单调递减的,A 到 B 再到 A 根本不会出现,所以直接用”库存值”做比较是安全的。
但只要有回补逻辑就不安全了——超时未支付释放库存、退款回补、运维手动改库存,这些都会让值升回去:
初始库存:100
T1: 读到 100
T2: 读到 100
T1: 扣减成功 → 99
T2: 执行回补(超时释放)→ 100 ← 库存值回到了 100
T3: 有人下单 → 99
T1: 准备提交扣减,比较"当前值 == 100" → 成立!
但实际上这期间已经有人动过这一行,T1 读到的"100"已经不是它当初看到的那个 100 了
怎么解决:用单调递增的版本号代替原值比较
版本号只增不减,“回退”在版本号上表现为 v 到 v+1 再到 v+2,永远回不到 v。所以 WHERE version = v 一定会失败,冲突被正确识别。
库存 100 → 99 → 100 库存值:不可靠(回到过 100)
version 7 → 8 → 9 版本号:永远不等于 7 ✅
不同场景的处理方式
| 场景 | 是否存在 ABA | 处理方式 |
|---|---|---|
| 纯扣减库存(只减不增) | 不存在 | 直接比较库存值即可 |
| 有释放/退款回补的库存 | 存在 | 必须用单调递增的 version |
| 无锁栈、无锁队列 | 存在 | 用带 tag 的指针,或版本号 |
| 分布式锁 | 存在(锁被释放后又被别人获取) | 用唯一 token 标识持有者,释放时校验 token |
| 账号余额(可加可减) | 存在 | 用版本号,或用数据库的行锁 |
一句话总结:ABA 问题的根因是”用值表达状态”,而值可以复用;解法是”用历史表达状态”,即单调递增的版本号。这也正是数据库乐观锁默认推荐版本号而不是直接比较原值的原因。
乐观锁用得好不好,细节比原理重要得多。下面这些是踩过坑之后总结出来的。
1. 版本号必须单调递增,永不回退
SET version = version + 1
不要在业务失败时把 version 改回旧值,也不要在重试时复用旧的 version。版本号的作用是”记录这一行被改过几次”,一旦允许回退,它的判别能力就没了。
2. 重试必须有上限、退避和抖动
import random
import time
MAX_RETRY = 3
BASE_DELAY = 0.005
def deduct_with_retry(product_id: int) -> bool:
for attempt in range(MAX_RETRY):
row = load_product(product_id)
if row is None or row.stock < 1:
return False # 库存不足,不用重试
if try_update(row.id, row.version): # 条件更新,影响行数为 1
return True
# 冲突了:退避 + 随机抖动后重试
delay = BASE_DELAY * (2 ** attempt) * (1 + random.random())
time.sleep(delay)
return False # 超过上限,交给上层降级
为什么必须加抖动:如果没有随机因子,所有冲突的请求会在同一毫秒退避、又在同一毫秒重试,形成整齐划一的”惊群”。抖动把重试打散开。
3. 每次重试必须重新读取
重试时如果还拿着上一次的 version 去更新,一定还是失败。正确做法是重新 SELECT,拿到新的 version 和新的 stock,再走一遍判断。
4. 临界区里不要做慢操作
持有一个”读到的版本”的这段时间越长,别人的冲突概率越高。这段时间里不要做 RPC 调用、文件 IO、发消息、日志落盘。把慢操作挪到更新成功之后。
5. 监控重试率
重试率 = 重试次数 / 总请求数
这是乐观锁最核心的健康指标。重试率突然升高,意味着某个热点行变热了,或者有别的问题正在制造冲突。重试率是领先指标——它比”扣减失败率”更早暴露问题。
6. 重试预算要和超时时间一起设计
如果一次请求允许 3 次重试,每次 SQL 耗时 20ms,那么超时时间至少要覆盖 3 乘 20ms 再加退避时间,否则客户端超时了、服务端还在重试,白白消耗数据库资源。
7. 乐观锁不能替代唯一约束
乐观锁解决的是”并发更新丢失”;“同一个用户不能下两单”这种业务唯一性,仍然要靠订单表的唯一索引来保证。
8. 高冲突热点不要硬用乐观锁
当冲突率高到重试策略注定失败时(比如 50 万人抢 100 件),再精巧的重试策略也救不了。这时候要换思路——把库存搬到 Redis,用原子操作在入口就把 99.9% 的无效请求挡掉,这正是第 4 章要讲的内容。
回到最初的问题:乐观锁到底够不够用?把不同并发量级放在一起看,答案就出来了。
不同场景的性能对比
| 场景 | 并发量 | 库存 | 悲观锁性能 | 乐观锁性能 | 推荐 |
|---|---|---|---|---|---|
| 后台管理 | 10 | 充足 | ⭐⭐⭐ | ⭐⭐⭐⭐⭐ | 乐观锁 |
| 普通电商 | 100 | 充足 | ⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ | 乐观锁 |
| 促销活动 | 1000 | 100 | ⭐⭐⭐ | ⭐⭐⭐⭐ | 乐观锁 |
| 秒杀活动 | 10000 | 100 | ⭐⭐ | ⭐⭐ | 都不够 |
| 超级秒杀 | 100000 | 100 | ⭐ | ⭐ | 都不够 |
关键结论
结论一:冲突率低的地方,乐观锁是明确更优的解。
后台管理、库存充足时的普通电商订单,冲突极少,乐观锁几乎没有额外开销,却省掉了悲观锁的全部阻塞成本。
结论二:冲突率高的地方,乐观锁会退化成”更贵的悲观锁”。
冲突率 = 并发请求数 / 可售库存
秒杀场景:500,000 / 100 = 5000 倍
单次请求的成功概率 ≈ 1 / 5000
期望需要重试 ≈ 5000 次
而每一次重试又会让冲突率进一步上升
结论三(最关键的):乐观锁不是”秒杀的答案”。
这是最容易被误解的一点。乐观锁解决的是”数据库这一层如何安全地扣减库存”,它从来没有解决”50 万 QPS 怎么进到数据库”。用乐观锁去硬扛 50 万 QPS,就像给一辆自行车的轮胎换成了更高级的材质——它还是扛不住这个速度。
正确的分工:
Redis 原子扣减 → 在 50 万 QPS 下完成筛选,挡掉 99.9% 的无效请求
MySQL 条件更新 → 在几千 QPS 下做最后确认,保证正确性
对账任务 → 兜住所有在线手段都没覆盖到的差异
所以真正该记住的一句话是:乐观锁是数据库层面的正确解,但在秒杀这种极端场景下,它的正确定位是”最后一道防线”,而不是”流量入口”。
第 4 章开始,我们把库存预扣搬到 Redis。
乐观锁的原理、ABA 和实践都讲完了。带着下面三个问题往下走,会更容易理解第 4 章为什么要做架构级的改造。
问题 1:乐观锁为什么在秒杀场景性能下降?
提示:
- 秒杀:50万人抢100台手机
- 冲突率 = 并发数 / 库存 = 500000 / 100 = 5000倍
- 意味着什么?
解题思路
关键在于先把冲突率算成一个具体数字,再看乐观锁在”冲突率极高”时为什么会从优势变成灾难。乐观锁的”乐观”是有前提的,秒杀场景恰好把这个前提彻底打破。
详细步骤
-
算出冲突率:并发请求数除以可售库存,500,000 除以 100,等于 5000 倍。乐观锁的整个设计前提是”冲突很少”,5000 倍冲突直接违背了这个前提。
-
算单次成功率:乐观锁依赖
WHERE version = ?命中。5000 个并发里只有 1 个能命中,单次成功率约等于 1/5000。 -
算期望重试次数:要重试大约 5000 次才能期望成功一次。而每一次重试都是一次 SELECT 加一次 UPDATE,都是实打实的数据库往返。
-
看到重试风暴的自我放大:N 个请求每个重试 5000 次,数据库实际承受的 QPS 被放大了 5000 倍。原本 50 万 QPS 的入口压力,在数据库侧变成了天文数字。
-
对比悲观锁的失败模式:
维度 悲观锁 乐观锁 冲突时的表现 排队等待,串行推进 失败后重试,成千上万次重试 打到数据库的请求数 约等于 1 次/请求 1 次加全部重试 冲突高时的表现 慢,但稳定、可预测 雪崩,自我放大 失败方式 用户等太久后超时 数据库被打死,所有人一起失败 -
最后是时间问题:用户只会等几秒。库存早就在前 100 个成功的请求里卖完了,后面那 50 万次重试毫无意义,却把数据库彻底拖垮。乐观锁在秒杀里不是”慢一点”,而是”把系统打死”。
最终答案
因为乐观锁的收益完全建立在”冲突率低”这个前提上。秒杀的冲突率是 5000 倍,单次成功率只有 1/5000,期望需要 5000 次重试;而重试又会把数据库 QPS 放大 5000 倍,形成自我强化的重试风暴。结果比悲观锁更糟——悲观锁至少是稳定地慢。
问题 2:如何优化乐观锁在秒杀场景的表现?
提示:
- 能否减少并发数?(限流)
- 能否减少冲突?(队列)
- 能否提前筛选?(缓存)
解题思路
三条提示对应三个不同的层次,但它们其实在做同一件事——把参与竞争的请求数从 50 万降到几百。乐观锁本身不解决入口流量问题,所以只能在它前面做文章。
详细步骤
-
减少并发数(限流):用令牌桶把瞬时的 50 万 QPS 削成系统能承受的速率,超出的请求快速失败。代价是相当一部分用户直接拿不到票——但在秒杀里这个代价是被接受的,因为本来就只有 100 件货。→ 第 5 章
-
减少冲突(队列):把并发请求排进队列串行处理,冲突率降到接近 0,乐观锁就退化成普通 UPDATE。代价是用户要多等一会儿。→ 第 4.2 节
-
提前筛选(缓存):在 Redis 里用原子操作做预扣,判断和扣减一步完成,把 99.9% 的无效请求挡在数据库之前。数据库只需要处理真正成功的那些。→ 第 4.1 节
-
把三条组合起来,才是一套完整方案:
限流(削掉总量) ↓ 答题 / 验证码(打散到达时间,防脚本) ↓ Redis 原子扣减(快速筛选,挡掉 99.9%) ↓ 消息队列(串行化,平滑地写库) ↓ MySQL 条件更新(最终确认) ↓ 对账(兜底) -
诚实地说清每条的代价:限流损害体验(秒杀里可接受),队列增加延迟(可接受),缓存增加一致性问题(用对账兜底)。没有免费的优化,每一条都在花钱。
-
回到问题的本意:如果只问”如何优化乐观锁”,答案是”减少冲突”;但秒杀真正的问题是”50 万 QPS 怎么进到数据库”,那是一个架构问题,不是锁的问题。
最终答案
三个方向都要用——限流削总量、队列削冲突、缓存提前筛——但本质是同一个动作:把参与竞争的请求数从 50 万降到几百。同时要清楚乐观锁的位置:它保住数据库层面的正确性,但不是入口流量的解决方案。
问题 3:还有什么更好的方案?
提示:
- 数据库是瓶颈
- 能否不用数据库?
- Redis、消息队列?
解题思路
提示已经指出了方向:数据库是瓶颈,能否不用数据库? 但要注意不是”彻底不用数据库”——订单和成交记录必须落在 MySQL,要换的是”谁来承担 50 万 QPS 的筛选”。
详细步骤
-
先承认乐观锁的价值:它解决了”数据库层面如何安全扣减库存”的问题。这部分不需要推翻,要换的是它所处的位置。
-
重新分工:
用户请求 ↓ Redis Lua 原子扣减 ← 在 50 万 QPS 下完成"还有没有货"的判断 ├─ 没货 → 直接返回"已售罄",到此为止,不打扰任何后端 └─ 有货 ↓ 消息队列(Kafka / RocketMQ) ↓ 消费者:扣 MySQL 库存(条件更新)+ 创建订单 ↓ 对账任务:定期比对,修复差异 -
每层各司其职:
层 承担什么 代价 Redis 原子扣减 高频、轻量、绝大多数结果是”没有货” 数据可能丢,需要对账 消息队列 削峰、串行化、可靠投递 增加延迟,增加运维复杂度 MySQL 条件更新 最终确认、强一致、持久化 吞吐只有几千 QPS 对账 兜住所有在线手段的漏网之鱼 有延迟,但成本低 -
数据一致性怎么保证:Redis 扣减成功不等于订单创建成功,两边之间隔着一条消息链路。答案是接受最终一致性,用三件套保证收敛——消费者幂等(订单号唯一索引)、MySQL 扣减带
stock >= 1条件、对账任务定期比对。详见第 6 章。 -
这才是”更好”的标准:不是 QPS 更高,而是在 QPS 更高的同时,一致性没有变差。乐观锁单独用是”QPS 降了但仍然打不动”,新架构是”QPS 上去了而且打得住”。
最终答案
用 Redis 的 Lua 原子扣减承担入口筛选,用消息队列承接削峰和可靠投递,MySQL 的条件更新保住正确性,对账负责兜底。乐观锁并没有被废弃,它退到了最后一层——在几千 QPS 的低流量下做正确的最终确认。
发现内容有问题?
告诉我们哪里需要改进。
