队列串行:使用消息队列串行处理请求

问题:Redis扣减后,数据库怎么办?🤔

上一节我们学会了用Redis原子操作扣减库存:

新的问题出现了:

场景:用户购买成功
1. Redis扣减库存:stock = 100 → 99 ✅
2. 创建订单:需要写入MySQL ❌
3. 扣减MySQL库存:stock = 100 → 99 ❌

问题:
- 如果直接操作MySQL,又会回到数据库瓶颈
- 如果不操作MySQL,Redis和MySQL数据不一致
- 如何在保证性能的同时,完成数据库操作?

解决思路:使用消息队列!

上一节把”判断库存并扣减”这个动作搬到了 Redis,本节要搬走的是”创建订单”这个动作。队列的作用,就是给 Redis 和 MySQL 之间加一道缓冲。

什么是消息队列?📨

消息队列(Message Queue)是一个进程间的通信中间件:生产者把消息放进队列,消费者按自己的节奏取走,双方互不感知对方的存在。

生产者                     消息队列                      消费者
(秒杀服务)              (Redis List)                  (订单服务)
   │                          │                          │
   │  LPUSH order:queue       │                          │
   ├─────────────────────────▶│                          │
   │                          │  BRPOP order:queue       │
   │                          │◀─────────────────────────┤
   │                          │─────────────────────────▶│

它给系统带来三个能力:

能力含义在秒杀里的价值
解耦生产者不需要知道谁在消费、消费要多久秒杀服务和订单服务可以独立部署、独立扩容
异步生产者发完消息立刻返回,不用等结果用户不必等数据库写完才拿到响应
削峰突发流量先堆在队列里,消费端按能力慢慢处理数据库只面对它能承受的写入速率

为什么必须引入它

把三种做法放在一起对比,差别就清楚了:

方案生产者做什么消费端压力失败影响一致性窗口
直接调用同步等数据库写完与入口同量级,50 万 QPS 打库当场失败,用户可见无(当场确定)
线程池提交任务后不等仍受队列长度限制,线程池满则拒绝任务可能丢失秒级
消息队列投递消息即返回由消费者数量和速度决定转成后台重试秒到分钟级

直接调用的致命之处在于:生产者被消费端的速度绑架了。 50 万 QPS 的入口,配上 1 万 QPS 的数据库,结果是 49 万 QPS 的请求在数据库连接池上排队、超时、重试,把数据库彻底压垮。引入队列之后,生产者只需要面对队列的写入速度(Redis 的量级),消费端只需要面对自己的处理能力。

投递语义:为什么一定会重复

队列的语义有三种,而生产系统实际能做到的只有一种:

语义含义现实
at-most-once最多一次,可能丢可以做到,但会丢单
at-least-once至少一次,可能重消息队列的默认语义
exactly-once恰好一次跨系统代价极高,基本做不到

“可能重”不是缺陷,是分布式系统的常态:消费者处理完、还没来得及 ACK 就断电了,消息只能被重新投递。所以队列系统必须配套两个机制——幂等和重试。这正是下一页要展开的内容。

为什么用 Redis List

业界的消息队列有 Kafka、RocketMQ、RabbitMQ。这一页用 Redis List,因为它在我们已有的技术栈里,而且它具备演示队列全部语义所需的能力:

  • LPUSH / BRPOP 是原子命令,不需要额外的客户端锁;
  • BRPOP 是阻塞的,没有消息时挂起连接,不产生空转轮询;
  • Redis 本身就有主从、集群和持久化能力,运维成本几乎为零。

生产环境的选型要看消息规模、吞吐、持久化要求和运维成本,而不是看哪个名字更响。


实现方案:Redis List作为消息队列 🔧

方案架构

   生产者(秒杀服务,10 个实例并发写)
        │  LPUSH order:queue:{1001}
        ▼
   ┌──────────────────────────────────────────┐
   │  Redis List:order:queue:{1001}          │
   │  队头 ← LPUSH 入队                       │
   │  队尾 ← BRPOP 出队                       │
   │  语义:先进先出(FIFO)                   │
   └──────────────────────────────────────────┘
        │  BRPOP(阻塞,5 秒超时)
   ┌────┴────────┬──────────────┐
   ▼             ▼              ▼
┌────────┐  ┌────────┐    ┌────────┐
│消费者 1 │  │消费者 2 │    │消费者 N │   ← 竞争消费
└────┬───┘  └────┬───┘    └────┬───┘     一条消息只被其中一个取走
     │           │            │
     └───────────┴────────────┘
                 ▼
        MySQL:写订单 + 扣库存

几个关键设计

1. 方向:LPUSH + BRPOP,或 RPUSH + BLPOP

两种组合都是 FIFO,选哪种都行,但两个命令必须配套且方向相反:

LPUSH + BRPOP  →  左进右出 = FIFO  ✅
LPUSH + BLPOP  →  左进左出 = LIFO  ❌ 后面的请求先被处理
RPUSH + BRPOP  →  右进右出 = LIFO  ❌

2. 必须用阻塞命令,不能用两条命令拼

❌ 错误写法:
   LPOP queue     # 取出
   ... 处理 ...
   LPUSH queue    # 放回(处理失败时)
   → 两条命令之间如果进程崩溃,消息就永久丢失
   → 而且多个消费者会互相抢消息,顺序彻底乱了

✅ 正确写法:
   BRPOP queue 5  # 原子地取出,没有消息时阻塞等待

3. 队列按活动隔离

不同场活动的流量不应该互相干扰:

order:queue:{1001}      活动 1001 的下单队列
order:queue:{1002}      活动 1002 的下单队列
order:dead:{1001}       活动 1001 的死信队列
order:processing:{1001} 活动 1001 的处理中队列

用 hash tag 包裹活动 ID({1001}),是为了在 Redis 集群下让同一活动的多个 key 落在同一个 slot——后面 Lua 脚本要同时操作它们,跨槽会直接报错。

4. 消息体要小

消息体只放消费者真正需要的字段:

{"order_id":"A202410110001","user_id":9527,"product_id":1001,"quantity":1,"ts":1731273600000}

不塞商品名称、图片 URL、活动规则这些消费者用不到的东西。每条消息多 100 字节,一百万条积压就是多 100MB 内存。

5. 队列长度必须监控

LLEN order:queue:{1001} 是最直接的健康指标,它同时也是容量预警的信号。

方案落地

生产者:投递

import json

QUEUE_KEY = 'order:queue:{1001}'

def enqueue_order(order: dict) -> int:
    """投递一条下单消息,返回投递后的队列长度"""
    payload = json.dumps(order, ensure_ascii=False, separators=(',', ':'))
    return r.lpush(QUEUE_KEY, payload)

生产者在扣减库存成功之后才投递消息。顺序反了就会出现”有订单但没扣库存”,那是最危险的一种错误。

更稳妥的做法:把扣减和投递放进同一个 Lua 脚本(见 4.3 节的 deduct_and_enqueue.lua),彻底消除两步之间的窗口。

消费者:取与处理

def consume_forever(queue_key: str = QUEUE_KEY):
    while True:
        # BRPOP:队列为空时阻塞等待,最多等 timeout 秒
        raw = r.brpop(queue_key, timeout=5)
        if raw is None:
            continue          # 超时了,重新阻塞即可

        msg = json.loads(raw)
        try:
            create_order(msg)          # 写 MySQL:插订单 + 扣库存
        except Exception:
            schedule_retry(raw, msg)   # 失败重试(4.3 节详解)
            continue
        # 处理成功,消息自然出队,无需额外 ACK

用 BRPOP 取出消息,就意味着消息在弹出的一瞬间就”离开”了队列。 这带来一个致命问题:如果消费者在处理过程中崩溃,这条消息既不在队列里,也没有处理成功——它丢了。

解决办法是处理中队列,下一页会详细展开:

BRPOPLPUSH order:queue:{1001} order:processing:{1001}
  → 原子地把消息从队列挪到处理中队列
  → 处理成功后从处理中队列删除(ACK)
  → 消费者崩溃后,处理中队列里的残留消息可以被重新捞回来

Redis 的可靠性配置

队列能不能扛住故障,一半取决于 Redis 的配置:

  # 持久化:消息落盘,Redis 重启不丢
appendonly yes
appendfsync everysec

  # 淘汰策略:绝不能淘汰队列 key
maxmemory-policy noeviction

maxmemory-policy noeviction 这一条尤其关键。 如果开了 allkeys-lru,Redis 内存吃紧时会主动淘汰 key——而队列 key 在 LRU 眼里就是”很久没被访问的冷数据”(消费者不取它的时候它就是冷的),于是它会在毫不知情的情况下被删掉。那才是真正意义上的静默丢单,而且没有任何报错。

同理,队列所在的 Redis 实例必须有独立的内存配额,不要和缓存业务混用,否则缓存的波动会把队列挤掉。

几个容易踩的坑

坑表现做法
阻塞连接被复用BRPOP 阻塞期间连接超时,抛异常消费者用独立连接池,阻塞操作独占一条连接
超时时间设成 0永不返回,进程无法优雅退出设 1-5 秒的超时,循环里重新阻塞
消费者数量超过队列长度多出来的消费者空转,白占连接消费者数量按队列长度和 DB 能力动态调整
队列无限增长Redis 内存打满监控 LLEN,超阈值触发降级或限流
消息体塞太多字段内存翻倍,序列化变慢只放消费端需要的字段

队列的作用:削峰填谷 📊

削峰填谷是队列最经典的用途,用图看最清楚:

请求速率(QPS)
  ^
  |                    峰值 500,000
  |                        /\
  |                       /  \
  |                      /    \
  |_____________________/      \___________________
  |          消费能力 5,000 ──────────────────────
  +----------------------------------------------------> 时间
        -10s      0s   +3s                +5min

流量在 3 秒内冲到 50 万 QPS,而消费者只能以 5,000 QPS 的速度处理。中间的差值不会消失,它会变成队列里的积压。

积压量怎么算

积压消息数 ≈ 峰值持续时间 × (峰值速率 - 消费速率)

50 万 QPS 峰值持续 3 秒,消费能力 5,000 QPS:
  积压 = 3 × (500,000 - 5,000) = 1,485,000 条

这 149 万条消息,每条按 200 字节算:

1,485,000 × 200B ≈ 297 MB

这就是队列内存必须提前算的原因。 一个 100 件库存的秒杀活动,队列里可能堆着上百万条请求消息——大部分注定是抢不到的。如果没提前预留内存,Redis 会先于数据库被打爆。

填谷:队列的另一面

削峰是把高峰”削”平,填谷则是让低谷时段把队列消化掉。

高峰(0-3秒)      积压 149 万条
低谷(3秒-5分钟)  消费者按 5,000 QPS 慢慢消化
消化完需要:      1,485,000 ÷ 5,000 ≈ 297 秒 ≈ 5 分钟

5 分钟用户拿不到结果,秒杀就失去了意义。 所以队列不是无限的,它是一个有容量、有延迟代价的缓冲区:

入口流量 50 万 QPS
   ↓ 队列缓冲(削峰)
消费能力 5,000 QPS
   ↓ 决定用户等待时长的,是「积压量 ÷ 消费速率」
最终结果:用户最长等 5 分钟

排队系统(第 5 章)解决的正是这个问题:它在入口处按一个受控的速率放行,让进到队列里的消息量恰好等于消费能力,队列从一开始就不会堆积。用户等的时间,从 5 分钟降到几秒。

削峰填谷的收益与代价

维度收益代价
数据库只面对 5,000 QPS 的写入,不再被打挂消费速度受限于 DB,要靠加机器提
用户拿到的是”处理中”,而不是超时要等结果,体验需要设计
系统故障被隔离在队列后面队列挂了、内存不足,都要单独处理
数据—存在不一致窗口,需要对账兜底

队列把”扛不住流量”变成了”处理得慢”。 慢可以优化,可以扩容,可以慢慢来;扛不住只能宕机。


队列消费策略 📋

队列里有了消息,怎么消费决定了系统的吞吐和正确性。几种常见策略:

策略做法适用场景风险
单消费者串行一个进程从头消费到尾顺序敏感、吞吐要求低积压快
多消费者竞争多个进程抢同一队列,谁抢到谁处理订单创建这类无序要求的高吞吐场景顺序不保证
广播消费每个消费者都收到全量消息缓存刷新、索引重建重复放大
批量拉取一次取 N 条批量处理减少网络往返、提升吞吐延迟变差

秒杀的下单消息适合多消费者竞争:每条订单是独立的,谁先处理谁处理,不需要保证全局顺序。

三个必须知道的语义

1. 竞争消费:一条消息只会被一个消费者处理

队列:[m1, m2, m3]
消费者 A 取走 m1
消费者 B 取走 m2
消费者 C 取走 m3
→ 三条消息各被处理一次,不会重复

2. 顺序只在单队列单消费者内成立

一旦有多个消费者,Redis List 的 FIFO 只保证”出队顺序”,不保证”完成顺序”。消费者 A 拿到 m1 慢一点,消费者 B 拿到 m2 先完成——完成顺序就乱了。

对订单创建来说这通常没问题(订单之间没有依赖)。但如果有依赖(比如”创建订单”必须在”扣库存”之前),就必须用分区队列:按某个键(比如用户 ID 或商品 ID)做哈希,同一个键的消息固定进同一个队列,由同一个消费者按序处理。

3. ACK 的位置决定可靠性

❌ 取出即视为成功(相当于 at-most-once)
   → 处理中崩溃,消息永久丢失

✅ 处理成功后再确认(at-least-once)
   → 处理中崩溃,消息会被重新投递
   → 代价是可能重复,所以必须幂等

多消费者实现

多消费者的实现其实非常简单——多个进程连同一个 Redis,各自阻塞弹出就行,Redis 保证一条消息只会被其中一个取走。

  # consumer_worker.py
import json
import os
import signal
import time

WORKER_ID = os.getenv('WORKER_ID', 'worker-1')
QUEUE_KEY = 'order:queue:{1001}'
PROCESSING_KEY = 'order:processing:{1001}'

running = True

def stop(signum, frame):
    global running
    running = False

signal.signal(signal.SIGTERM, stop)

def consume_forever():
    while running:
        # 原子地把消息挪到处理中队列
        raw = r.brpoplpush(QUEUE_KEY, PROCESSING_KEY, timeout=5)
        if raw is None:
            continue

        msg = json.loads(raw)
        try:
            create_order(msg)
        except Exception:
            schedule_retry(raw, msg)
            continue

        # 处理成功 → ACK(从处理中队列移除)
        r.lrem(PROCESSING_KEY, 1, raw)
        print(f'[{WORKER_ID}] 订单 {msg["order_id"]} 创建成功')

启动多个实例即可:

worker-1 → 消费者 1
worker-2 → 消费者 2
...
worker-20 → 消费者 20

启动时的崩溃恢复

消费者重启后,先把处理中队列里的残留消息捞回来:

def recover_stale_messages(queue_key: str, processing_key: str) -> int:
    """把处理中队列里的残留消息重新放回主队列"""
    recovered = 0
    while True:
        raw = r.rpoplpush(processing_key, queue_key)   # 原子地挪回主队列
        if raw is None:
            break
        recovered += 1
    return recovered

这一步是”消息不丢”的关键。 没有它,处理中崩溃的消息就永远卡在处理中队列里,用户既没有订单也没有任何提示。

消费者数量怎么定

消费者数量不是越多越好,它有一个硬上限:

消费能力 = 消费者数量 × 单条处理耗时(的倒数)

20 个消费者 × 单条 10ms  → 2,000 QPS
50 个消费者 × 单条 10ms  → 5,000 QPS

上限由 MySQL 的写入能力决定,而不是由消费者数量决定。 消费者超过数据库能承受的并发之后,多出来的消费者只会加剧数据库的锁竞争,把吞吐打下来。

而且这里还有一个约束:如果消息本身是有序的(同一个用户或同一个商品的消息需要串行处理),那消费者数量必须等于分区数,再多也没用——这就是分区队列的代价。

消费能力的监控

LLEN order:queue:{1001}                    队列积压长度
消费速率(每秒成功处理条数)                 消费者健康度
消息驻留时间 P99                           用户实际等待时间
重试率 / 死信长度                          失败情况

这四个指标要放在同一张看板上。 队列长度单独看没有意义——它大可能是在稳定消化,也可能是完全卡死,要结合消费速率一起判断。


性能对比:有无队列 ⚡

同一场活动(库存 100 件,50 万人抢),两种架构的对比:

指标同步直写 MySQL队列异步
入口峰值 QPS50 万(全部打到数据库)50 万打到 Redis
数据库峰值写 QPS50 万 ❌5,000(等于消费者能力)
系统实际吞吐5,000-20,000 QPS(受 DB 限制)100,000+ QPS(受 Redis 限制)
用户 P99 延迟300-800ms,失败时超时5-15ms 返回”处理中”
数据库被打挂的后果整场活动失败,不可恢复队列缓冲,数据库只处理成功请求
单条消息失败的影响当场失败,用户直接看到错误转成后台重试,用户无感
额外成本无队列内存、消费者机器、重试与幂等代码
数据一致性当场确定秒级窗口,需要对账

最关键的一行是”数据库被打挂的后果”。 同步架构下,数据库一挂就是整场活动失败,没有补救余地;队列架构下,数据库挂了只会让消费变慢,队列还在,数据库恢复后消息继续被消费——故障半径被队列缩小了一个数量级。

同样重要的是”单条消息失败的影响”。同步架构里,一条消息失败就是一次用户可见的失败;异步架构里,它变成一次后台重试,用户看到的只是”处理中”多持续了几秒。故障从用户的感知里消失了。

什么时候不该用队列

队列不是万能的,以下场景用队列反而是负担:

场景原因
低并发、必须立刻拿到结果队列只会增加延迟
强顺序依赖且无法分区队列会破坏顺序保证
单条业务逻辑极简单引入中间件的复杂度大于收益
需要用户立刻知道成败异步通知的复杂度高于直接返回

秒杀的场景恰好全部落在”该用队列”的那一侧:高并发、可以接受最终结果、单条逻辑不复杂、用户能接受”处理中”。第 1 章的”关键取舍”里说”异步排队能削峰,但用户要等待结果”——这一页就是在回答”这个取舍值得吗”。


想一想

问题 1:队列满了怎么办?

提示:

  • 队列容量有限
  • 用户持续下单
  • 如何处理队列溢出?
削峰填谷内存评估降级策略

解题思路

队列满了说明两件事同时发生:流量超过消费能力,而且缓冲区已经用完。这时候必须做取舍——要么让一部分请求失败(保护系统),要么让系统被压垮(谁都不想要)。没有第三条路,所以先要想清楚”宁可丢什么”。

详细步骤

  1. 先算容量,而不是等它满。队列内存 ≈ 峰值积压条数 × 单条消息字节数。提前按上一节的算例把内存配额留出来,比事后处理便宜得多。Redis 实例要有独立配额,不要和缓存混用。

  2. 设置硬上限并主动拒绝。用 LLEN 配合阈值做判断:

MAX_QUEUE_LEN = 200_000   # 提前算好的上限

if r.llen(QUEUE_KEY) > MAX_QUEUE_LEN:
    return 'BUSY'          # 明确拒绝:系统繁忙,请稍后再试

主动拒绝比静默丢弃好一万倍。 静默丢弃会让用户以为”我抢到了”却永远等不到结果;明确拒绝至少让用户知道发生了什么。

  1. 拒绝的顺序:先拒无效的,再拒有效的。队列快满时,优先挡掉”明显抢不到”的请求(库存已为 0、重复提交、已中过奖的用户),保留真正有机会的请求。这比一刀切地按先到先拒要公平得多。

  2. 配合上游限流。队列满的根因是入口流量超过消费能力,解法在入口而不是队列——第 5 章的限流和排队系统就是干这个的。队列是最后一道防线,不是唯一一道防线。

  3. 消费者侧加速。紧急时可以临时扩容消费者、增加单批处理条数,让积压尽快下去。但要记住消费能力的上限是数据库写入能力,加消费者超过这个点只会加剧锁竞争。

  4. 极端情况直接熔断。如果连 Redis 内存都快不够了(队列本身要占内存),要能立刻切换到”直接拒绝 + 提示稍后再来”的降级模式,保住活动页面和已成功的订单。

最终答案

队列满时必须主动、快速、可解释地拒绝,并按”先拒无效请求、再拒有效请求”的顺序处理;同时在入口用限流和排队把流量削到消费能力以内,让队列根本不发生溢出。队列内存必须提前算、提前留配额,并和缓存业务物理隔离。

问题 2:消费者挂了怎么办?

提示:

  • 消费者处理订单时崩溃
  • 队列中的消息还在吗?
  • 如何保证消息不丢失?
消息可靠性ACK 机制崩溃恢复

解题思路

“消费者挂了”要拆成两个完全不同的问题:崩溃时消息还在不在队列里(取决于用的是什么弹出命令),以及消息在但会不会被重复处理(取决于幂等)。前者是可用性问题,后者是正确性问题。

详细步骤

  1. 先确认弹出方式。用 BRPOP(或 LPOP)弹出,消息在弹出的瞬间就离开了队列——消费者此刻崩溃,消息永久丢失。这是最危险的一种实现。

  2. 改用”处理中队列”。用 BRPOPLPUSH 原子地把消息从主队列挪到处理中队列:

主队列 [m1, m2, m3]
  → BRPOPLPUSH 取出 m1
主队列 [m2, m3]        处理中队列 [m1]
  1. 崩溃后的恢复:消费者重启时,先扫描处理中队列,把残留消息挪回主队列:
while True:
    raw = r.rpoplpush(PROCESSING_KEY, QUEUE_KEY)
    if raw is None:
        break

这一步必须在消费者开始处理新消息之前执行,否则新消息会插到旧消息前面,顺序就乱了。

  1. 处理成功后再 ACK:从处理中队列删除消息,才是真正的”确认完成”。顺序是”处理 → 提交 → 删除”,任何一步崩溃,消息都会留在处理中队列里等待重投。

  2. 重复处理是必然的,必须幂等。消息被重新投递后,第二次处理必须产生和第一次相同的结果。落地上就是:订单号唯一索引 + 幂等键(详见 4.3 节的「幂等性设计」)。没有幂等,崩溃恢复就会变成重复下单和重复扣库存。

  3. 优雅停机:收到 SIGTERM 后先停止取新消息,把手里的消息处理完再退出;退出前把处理中队列里的残留消息挪回主队列。避免每次发布都产生一批”卡在处理中队列”的消息。

最终答案

用 BRPOPLPUSH 把消息原子地挪到处理中队列,处理成功后再删除(ACK),消费者启动时先把处理中队列的残留消息挪回主队列。因为重投必然发生,消费端必须幂等——否则崩溃恢复会直接变成重复订单。

问题 3:如何保证Redis和MySQL的一致性?

提示:

  • Redis扣减成功
  • 队列写入成功
  • MySQL操作失败怎么办?
最终一致性补偿对账

解题思路

先看清楚这个场景的性质:Redis 扣减成功、消息也成功入队了,但消费端处理 MySQL 时失败了。这时候 Redis 少了一件可售库存,MySQL 里没有对应订单——少卖,不是超卖。因此要回答的问题是”怎么把多占的库存还回去”,而不是”怎么保证两边同时一致”。

详细步骤

  1. 失败要分类。不是所有失败都该重试:
失败类型例子处理
瞬时故障连接超时、主从切换指数退避后重试(4.3 节的「重试机制详解」)
业务失败MySQL 库存不足、参数非法不重试,直接走补偿
系统故障代码 bug、数据格式错有限次重试后进死信队列 + 告警
  1. 重试要能安全地重试。因为重投意味着同一条消息可能被处理多次,所以消费端必须幂等:订单号唯一索引 + 幂等标记(4.3 节)。先有幂等,再谈重试。

  2. 业务失败要走补偿:MySQL 库存不足,说明这次扣减不成立,必须把 Redis 的库存还回去,同时把订单标记为失败并通知用户。补偿动作本身要幂等——写成”设置成目标值”而不是”加 1”,重复执行才不会越补越多。

  3. 最终靠对账收敛。在线机制(重试、死信、补偿)都可能同时失效,所以要有一条独立的、不依赖同步链路的校验路径:

初始库存 = MySQL 已售 + MySQL 待支付占用 + Redis 剩余可售 + 异常差异

差异里的”Redis 剩余偏多”就是这类场景,补回库存即可(第 6.2 节的「库存对账和数据修复机制」)。

  1. 一致性窗口要被监控。记录每个订单的”Redis 扣减时间”和”MySQL 提交时间”,窗口 P99 超过阈值就要告警。窗口突然拉长,往往意味着消费者变慢或队列积压。

最终答案

承认这是一个最终一致问题:Redis 已扣但订单没建成属于”少卖”,靠三层机制收敛——瞬时失败退避重试(靠幂等保证安全)、业务失败立即补偿回库存、最终由对账任务扫描差额补回。切忌在消费者失败时直接”把 Redis 加回去”,那样会把一个可恢复的失败变成超卖。

发现内容有问题?

告诉我们哪里需要改进。