乐观锁:使用版本号实现乐观锁

问题:悲观锁太慢,如何提升性能?🤔

上一节我们学习了悲观锁,它有一个致命问题:

悲观锁性能测试结果:
- 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 = ?跨进程、持久化数据库表,秒杀落库
原子类 CASAtomicInteger.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

第三步:找到关键差异

  1. 悲观锁的开销是”必付”的。 即使完全没有冲突,每个请求也要付出加锁、解锁、事务提交的代价。乐观锁在无冲突时只付出一次普通 UPDATE。
  2. 悲观锁把并发变成串行。 100 个请求抢同一行,就是 100 次串行事务,耗时约等于 100 乘以单次事务时间。乐观锁是 100 个请求并行跑,总耗时约等于 1 次请求时间加上少量重试。
  3. 乐观锁的代价只由少数人承担。 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充足⭐⭐⭐⭐⭐⭐⭐⭐⭐乐观锁
促销活动1000100⭐⭐⭐⭐⭐⭐⭐乐观锁
秒杀活动10000100⭐⭐⭐⭐都不够
超级秒杀100000100⭐⭐都不够

关键结论

结论一:冲突率低的地方,乐观锁是明确更优的解。

后台管理、库存充足时的普通电商订单,冲突极少,乐观锁几乎没有额外开销,却省掉了悲观锁的全部阻塞成本。

结论二:冲突率高的地方,乐观锁会退化成”更贵的悲观锁”。

冲突率 = 并发请求数 / 可售库存
  秒杀场景: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倍
  • 意味着什么?
乐观锁冲突率重试风暴

解题思路

关键在于先把冲突率算成一个具体数字,再看乐观锁在”冲突率极高”时为什么会从优势变成灾难。乐观锁的”乐观”是有前提的,秒杀场景恰好把这个前提彻底打破。

详细步骤

  1. 算出冲突率:并发请求数除以可售库存,500,000 除以 100,等于 5000 倍。乐观锁的整个设计前提是”冲突很少”,5000 倍冲突直接违背了这个前提。

  2. 算单次成功率:乐观锁依赖 WHERE version = ? 命中。5000 个并发里只有 1 个能命中,单次成功率约等于 1/5000。

  3. 算期望重试次数:要重试大约 5000 次才能期望成功一次。而每一次重试都是一次 SELECT 加一次 UPDATE,都是实打实的数据库往返。

  4. 看到重试风暴的自我放大:N 个请求每个重试 5000 次,数据库实际承受的 QPS 被放大了 5000 倍。原本 50 万 QPS 的入口压力,在数据库侧变成了天文数字。

  5. 对比悲观锁的失败模式:

    维度悲观锁乐观锁
    冲突时的表现排队等待,串行推进失败后重试,成千上万次重试
    打到数据库的请求数约等于 1 次/请求1 次加全部重试
    冲突高时的表现慢,但稳定、可预测雪崩,自我放大
    失败方式用户等太久后超时数据库被打死,所有人一起失败
  6. 最后是时间问题:用户只会等几秒。库存早就在前 100 个成功的请求里卖完了,后面那 50 万次重试毫无意义,却把数据库彻底拖垮。乐观锁在秒杀里不是”慢一点”,而是”把系统打死”。

最终答案

因为乐观锁的收益完全建立在”冲突率低”这个前提上。秒杀的冲突率是 5000 倍,单次成功率只有 1/5000,期望需要 5000 次重试;而重试又会把数据库 QPS 放大 5000 倍,形成自我强化的重试风暴。结果比悲观锁更糟——悲观锁至少是稳定地慢。

问题 2:如何优化乐观锁在秒杀场景的表现?

提示:

  • 能否减少并发数?(限流)
  • 能否减少冲突?(队列)
  • 能否提前筛选?(缓存)
限流削峰缓存预筛秒杀架构

解题思路

三条提示对应三个不同的层次,但它们其实在做同一件事——把参与竞争的请求数从 50 万降到几百。乐观锁本身不解决入口流量问题,所以只能在它前面做文章。

详细步骤

  1. 减少并发数(限流):用令牌桶把瞬时的 50 万 QPS 削成系统能承受的速率,超出的请求快速失败。代价是相当一部分用户直接拿不到票——但在秒杀里这个代价是被接受的,因为本来就只有 100 件货。→ 第 5 章

  2. 减少冲突(队列):把并发请求排进队列串行处理,冲突率降到接近 0,乐观锁就退化成普通 UPDATE。代价是用户要多等一会儿。→ 第 4.2 节

  3. 提前筛选(缓存):在 Redis 里用原子操作做预扣,判断和扣减一步完成,把 99.9% 的无效请求挡在数据库之前。数据库只需要处理真正成功的那些。→ 第 4.1 节

  4. 把三条组合起来,才是一套完整方案:

    限流(削掉总量)
      ↓
    答题 / 验证码(打散到达时间,防脚本)
      ↓
    Redis 原子扣减(快速筛选,挡掉 99.9%)
      ↓
    消息队列(串行化,平滑地写库)
      ↓
    MySQL 条件更新(最终确认)
      ↓
    对账(兜底)
  5. 诚实地说清每条的代价:限流损害体验(秒杀里可接受),队列增加延迟(可接受),缓存增加一致性问题(用对账兜底)。没有免费的优化,每一条都在花钱。

  6. 回到问题的本意:如果只问”如何优化乐观锁”,答案是”减少冲突”;但秒杀真正的问题是”50 万 QPS 怎么进到数据库”,那是一个架构问题,不是锁的问题。

最终答案

三个方向都要用——限流削总量、队列削冲突、缓存提前筛——但本质是同一个动作:把参与竞争的请求数从 50 万降到几百。同时要清楚乐观锁的位置:它保住数据库层面的正确性,但不是入口流量的解决方案。

问题 3:还有什么更好的方案?

提示:

  • 数据库是瓶颈
  • 能否不用数据库?
  • Redis、消息队列?
Redis 原子操作消息队列最终一致性秒杀架构

解题思路

提示已经指出了方向:数据库是瓶颈,能否不用数据库? 但要注意不是”彻底不用数据库”——订单和成交记录必须落在 MySQL,要换的是”谁来承担 50 万 QPS 的筛选”。

详细步骤

  1. 先承认乐观锁的价值:它解决了”数据库层面如何安全扣减库存”的问题。这部分不需要推翻,要换的是它所处的位置。

  2. 重新分工:

    用户请求
       ↓
    Redis Lua 原子扣减  ←  在 50 万 QPS 下完成"还有没有货"的判断
       ├─ 没货 → 直接返回"已售罄",到此为止,不打扰任何后端
       └─ 有货 ↓
    消息队列(Kafka / RocketMQ)
       ↓
    消费者:扣 MySQL 库存(条件更新)+ 创建订单
       ↓
    对账任务:定期比对,修复差异
  3. 每层各司其职:

    层承担什么代价
    Redis 原子扣减高频、轻量、绝大多数结果是”没有货”数据可能丢,需要对账
    消息队列削峰、串行化、可靠投递增加延迟,增加运维复杂度
    MySQL 条件更新最终确认、强一致、持久化吞吐只有几千 QPS
    对账兜住所有在线手段的漏网之鱼有延迟,但成本低
  4. 数据一致性怎么保证:Redis 扣减成功不等于订单创建成功,两边之间隔着一条消息链路。答案是接受最终一致性,用三件套保证收敛——消费者幂等(订单号唯一索引)、MySQL 扣减带 stock >= 1 条件、对账任务定期比对。详见第 6 章。

  5. 这才是”更好”的标准:不是 QPS 更高,而是在 QPS 更高的同时,一致性没有变差。乐观锁单独用是”QPS 降了但仍然打不动”,新架构是”QPS 上去了而且打得住”。

最终答案

用 Redis 的 Lua 原子扣减承担入口筛选,用消息队列承接削峰和可靠投递,MySQL 的条件更新保住正确性,对账负责兜底。乐观锁并没有被废弃,它退到了最后一层——在几千 QPS 的低流量下做正确的最终确认。

发现内容有问题?

告诉我们哪里需要改进。