Skip to content

5.1-4 消息积压的定位、扩容与处理 ​

所属:05 消息中间件 / 5.1 通用能力 分级:A 状态:◐ 初稿 关联:5.1-1、5.1-2、5.1-3、5.1-5、5.3-4、5.3-8、5.4-4、5.4-5、6.6-2

  • 题型:排查 / 场景 / 调优

  • 一句话结论:积压的本质是消费速率持续低于生产速率,先分三类定位——突发流量、消费变慢、消费停住——再按“扩消费者(受分区/队列数上限)→ 提单条吞吐(批量/异步/优化下游)→ 生产限流/降级 → 临时转存 → 最后才丢弃”的顺序处理。盲目加消费者通常没用:Kafka 消费者数超过分区数就是空闲,瓶颈往往在下游 DB/RPC,扩容还可能触发 Rebalance 风暴。积压是容量问题,不是“多点几下控制台”能解决的。

  • 分层要点:

    1. 先把数算清楚:积压量 lag、生产 TPS、消费 TPS、单条平均 RT、lag 增长斜率。清空时间 ≈ lag / (消费能力 − 生产速率);如果消费能力 ≤ 生产速率,加多少消费者都清不完,必须先降生产或提能力。没有这几个数,所有处理都是拍脑袋。
    2. 定位分三类:① 突发流量——生产 TPS 陡增,消费 TPS 正常;② 消费变慢——消费 TPS 下降,单条 RT 上升(下游慢、GC、DB 连接池、锁);③ 消费停住——消费 TPS 接近 0(毒消息无限重试、分区无消费者、Rebalance 风暴、线程池满、实例假死)。三类的处理完全不同。
    3. 三件套看哪些指标:Kafka 用 kafka-consumer-groups.sh --describe 或 JMX records-lag-max,看每个分区的 lag 与 CURRENT-OFFSET/LOG-END-OFFSET;RocketMQ 用 mqadmin consumerProgress 看 Diff Total 与每个队列的消费位点;RabbitMQ 看 messages_ready(堆积未投递)、messages_unacknowledged(投递未确认)、consumers 数量。ready 高是消费能力不足,unacked 高是消费者卡住/预取过多。
    4. 扩容有硬上限:Kafka 同一消费组的有效消费者数 ≤ 分区数,多出来的线程/实例分配不到分区、纯空闲;RocketMQ 消费者数受 readQueueNums 限制;RabbitMQ 可以多 consumer,但单队列的投递受 prefetch 与队列锁影响。扩容前先确认“分区/队列数够不够”,不够就要扩分区/扩队列——而这两件事都有代价(见第 7 条)。
    5. 提吞吐优先于加机器:批量消费(Kafka max.poll.records、RocketMQ consumeMessageBatchMaxSize)、批量写库(insert batch / rewriteBatchedStatements)、下游异步化、减少同步 RPC、复用连接池、加索引/缓存。先 profile 找单条 RT 的瓶颈:如果是 DB 慢,加消费者只会把 DB 打得更死。
    6. 消费“停住”的典型原因:毒消息反复重试堵住分区(顺序消费尤其明显,5.1-3);max.poll.interval.ms 超时被踢出组,反复 Rebalance;GC/STW 导致心跳超时;线程池满或阻塞队列堆积;下游超时时间过长;offset 提交失败;实例假死但心跳还在。定位靠线程栈 + 消费日志 + Rebalance 日志 + lag 曲线拐点。
    7. 扩分区/扩队列不是无痛的:Kafka 扩分区会改变 key → partition 的映射,同 key 的新旧消息可能落到不同分区,顺序被破坏(5.1-3),且已有 key 的局部性丢失;RocketMQ 扩队列需要 Topic 路由更新,历史消息不迁移,消费位点按队列维护;RabbitMQ 扩队列意味着改路由与消费者绑定。能扩消费者解决就不要扩分区。
    8. 应急有顺序,长期靠治理:应急顺序是“扩消费者 → 提批量/并发 → 降级非核心 → 生产限流 → 临时转存 → 丢弃(仅可丢数据)”;长期是容量规划(峰值 TPS × 冗余系数)、消费者压测、lag 告警(绝对值 + 增速 + 持续时长)、自动扩缩容、重试与死信隔离、生产端削峰。每一次积压都应该沉淀成容量基线。
  • 图/流程:

text
三类 lag 曲线:
  突发流量        消费变慢          消费停住
   ▲               ▲                ▲
   │    ╱          │   ╱╲           │ ╱
   │   ╱           │  ╱  ╲          │╱
   │──╱            │ ╱    ╲         │
   └──────▶ t      └──────▶ t       └──────▶ t
  生产陡增        斜率变缓          几乎水平
text
积压处理决策树:
  lag 持续上涨
    ├─ 消费 TPS ≈ 0?
    │    ├─ 有毒消息/异常 → 跳过/死信,恢复消费
    │    ├─ 无消费者/分区未分配 → 检查实例与 Rebalance
    │    └─ 线程池满/假死 → 重启/扩容/查栈
    ├─ 消费 TPS 下降?
    │    ├─ 下游慢 → 优化 SQL/RPC、加缓存、限流保护
    │    └─ GC/CPU → 查监控、扩实例
    └─ 生产陡增?
         ├─ 可降级 → 生产限流/合并消息
         └─ 不可降级 → 扩消费者(分区足够)+ 批量
text
临时转存(分区不够时的应急):
  原 topic(3 分区,积压 1 亿)
    → 临时消费者:只搬运、不做业务,快速写入
      → 临时 topic(30 分区)
        → 30 个消费者并行处理
  风险:重复(迁移与业务都写)、顺序丢失、临时 topic 容量
text
RabbitMQ 两种积压:
  messages_ready 高
    → 没有消费者/消费太慢 → 加 consumer、提 prefetch、优化处理
  messages_unacknowledged 高
    → 消费者拿到但没 ack → 卡住/处理慢/预取过多 → 查栈、降 prefetch
  • 版本/源码锚点:

    • Kafka:max.poll.records(默认 500)、max.poll.interval.ms(默认 300000,即 5 分钟)、session.timeout.ms(3.0+ 默认 45000)、heartbeat.interval.ms(3000)、fetch.min.bytes、fetch.max.wait.ms;kafka-consumer-groups.sh --describe --group、JMX records-lag-max;扩分区用 kafka-topics.sh --alter --partitions(只能增不能减)。
    • RocketMQ:consumeThreadMin/Max(默认 20/64)、consumeMessageBatchMaxSize(默认 1)、pullBatchSize(默认 32)、maxReconsumeTimes;mqadmin consumerProgress -g <group> 看 Diff Total;%RETRY%/%DLQ%。
    • RabbitMQ:messages_ready、messages_unacknowledged、consumers;rabbitmqctl list_queues name messages messages_ready messages_unacknowledged consumers;HTTP API /api/queues;basic.qos(prefetch);x-max-length 与溢出策略。
    • Spring:spring.kafka.listener.concurrency、spring.kafka.consumer.max-poll-records、spring.kafka.listener.ack-mode;Spring AMQP setConcurrency、setPrefetchCount、setBatchSize。
    • 自动扩缩容:KEDA kafka scaler / rabbitmq scaler 基于 lag 扩 Pod。
  • 积压原因与处理:

类别典型原因指标特征处理
突发流量大促、批量导入、上游重放生产 TPS 陡增,lag 斜率大扩消费者、生产限流、削峰
消费变慢下游 DB/RPC 慢、GC、锁消费 TPS 降、RT 升优化下游、扩实例、加缓存
毒消息反序列化失败、脏数据某分区 lag 不动,日志重复异常跳过/死信/修复数据
无消费者实例挂、分区未分配lag 全量上涨,consumers=0恢复实例、检查 Rebalance
Rebalance 风暴max.poll.interval 超时反复 rebalance 日志缩短处理、调大间隔
线程池满同步阻塞、慢调用活跃线程 100%、拒绝数上升扩池/异步化/限流
预取过多RabbitMQ prefetch 大unacked 高、ready 低降 prefetch
Broker 异常磁盘满、IO 高生产/消费都慢扩磁盘、迁移、限流
顺序阻塞顺序消费失败挂起队列单队列 lag 不动死信/修复/跳过(5.1-3)
  • 应急手段对比:
手段效果代价/风险适用
扩消费者线性提升(分区足够)分区上限、Rebalance、下游压力消费能力不足
提批量/并发提升单实例吞吐延迟上升、重复窗口变大单条 RT 小、可批处理
优化下游根治需要时间长期
生产限流立刻止血影响上游业务突发流量
降级非核心释放资源业务功能受损大促应急
临时转存突破分区限制重复/顺序/容量风险严重积压、分区不够
跳过毒消息恢复消费数据丢失/需补偿单条脏数据
重置 offset快速清 lag丢消息,慎用确认可丢/重放
丢弃最快数据丢失日志/埋点
  • 三件套扩容上限:
维度KafkaRocketMQRabbitMQ
并行单位partitionMessageQueuequeue + consumer
消费者上限= 分区数= 读队列数无硬上限,受 prefetch/队列影响
扩并行扩分区(破坏 key 顺序)扩读写队列加 consumer / 拆队列
消费进度offset(每分区)消费位点(每队列)ack + 队列深度
积压指标lagDiff Totalready / unacked
批量参数max.poll.recordsconsumeMessageBatchMaxSizeprefetch / batchSize
典型瓶颈分区数、下游队列数、下游单队列吞吐、prefetch
  • 关键参数:
参数默认作用积压时怎么调
Kafka max.poll.records500单次拉取条数适当增大,提升吞吐
Kafka max.poll.interval.ms300000两次 poll 最大间隔处理慢时调大,避免 Rebalance
Kafka session.timeout.ms45000(3.0+)会话超时与心跳配合
Kafka concurrency1容器线程数≤ 分区数
RocketMQ consumeThreadMax64消费线程按下游能力调
RocketMQ consumeMessageBatchMaxSize1批量条数增大提吞吐
RocketMQ pullBatchSize32拉取批量适当增大
RabbitMQ prefetch250(Spring)未 ack 上限积压且单条慢时降低
RabbitMQ concurrency1消费者数增加,但注意顺序
  • 监控与告警:
指标含义告警建议
lag / Diff Total积压量绝对值 + 持续 5 分钟增长
lag 增速恶化速度斜率 > 阈值
消费 TPS消费能力环比下降 30%
单条 RT处理耗时P99 超阈值
Rebalance 次数稳定性每小时 > N 次
重试/死信数量异常突增
messages_unacknowledged卡住/预取持续高位
消费者实例数容量少于分区数
  • 失效场景与定位:
现象根因处理
加了消费者 lag 不降消费者数 > 分区数先扩分区或减消费者
加消费者后更慢下游 DB 被打满先优化下游/限流
单分区 lag 不动毒消息阻塞查异常日志,跳过/死信
反复 Rebalancemax.poll.interval 超时缩短处理/调大间隔
消费线程 100%同步慢调用异步化、扩池、限流
unacked 很高prefetch 过大/处理卡住降 prefetch、查栈
扩分区后顺序错乱key 映射变化接受局部乱序或停机迁移
临时转存后重复搬运与业务并行幂等 + 切换开关
重置 offset 后数据缺失跳过未消费消息从备份/日志补偿
重启后 lag 暴涨位点回退/重复消费检查提交策略
  • 深挖点(面试官常追的 6 个):

    1. 为什么加消费者没效果:Kafka 的并行度由分区数决定,同一消费组内一个分区只能被一个消费者消费,第 N+1 个消费者分不到分区就空转;RocketMQ 同理受读队列数限制。另一个常见原因是瓶颈在下游——消费者越多,DB 连接和锁竞争越严重,吞吐反而下降。扩容前先看“分区数”和“单条 RT 的瓶颈在哪”。
    2. 毒消息怎么定位和处理:特征是某个分区的 lag 曲线完全水平、其他分区正常,日志里同一条消息反复报错(反序列化失败、字段缺失、脏数据)。处理不能靠无限重试:Kafka 可以 seek 跳过或投递到死信 topic;RocketMQ 达到 maxReconsumeTimes 进 %DLQ%;RabbitMQ basic.reject(requeue=false) 进 DLX。跳过前要留证据(消息体、offset、异常栈),事后补偿。
    3. Rebalance 风暴怎么来的:消费者处理一批消息超过 max.poll.interval.ms(默认 5 分钟),协调者认为它死了,触发 Rebalance;分区迁移后又重复消费,处理更慢,形成恶性循环。解法是缩小 max.poll.records、把耗时逻辑异步化、合理调大 max.poll.interval.ms,并避免实例频繁上下线。Rebalance 期间消费会短暂停摆,lag 会尖峰。
    4. 临时转存方案怎么做:当分区数不够、积压又很大时,起一个“搬运消费者”——只从原 topic 读、原样写入一个分区更多的临时 topic,不做业务;再用更多消费者处理临时 topic。要点:搬运要快(批量、异步、无业务逻辑)、要有幂等(切换期间可能重复)、要控制临时 topic 的保留时间与容量、切换要有开关。这是应急手段,不是常态架构。
    5. 扩分区/扩队列的代价:Kafka 扩分区后 hash(key) % partitions 的结果变了,同一个 key 的新消息可能写到不同分区,同 key 顺序被破坏,且历史消息不会迁移;RocketMQ 扩读队列后,新队列从最新位点开始消费,历史积压仍压在旧队列;RabbitMQ 拆队列要改绑定与路由。所以“扩分区”是架构变更,要走评估和灰度,不能当运维命令用。
    6. 积压和可靠性/顺序/幂等的关系:积压期间如果 TTL 到期,消息会被清理 → 丢(5.1-1);积压后的重放、offset 回退、Rebalance 会产生大量重复 → 幂等必须扛住(5.1-2);顺序消费失败会挂起整个队列,积压被放大,且不能靠加消费者解决(5.1-3)。积压不是孤立问题,它会把可靠性设计的短板全部暴露出来。
  • 追问链:

    1. 什么是消息积压? → 消费速率持续低于生产速率。
    2. 先看什么指标? → lag、生产 TPS、消费 TPS、RT。
    3. 怎么算清空时间? → lag / (消费能力 − 生产速率)。
    4. 积压分几类? → 突发流量、消费变慢、消费停住。
    5. Kafka 怎么看 lag? → kafka-consumer-groups.sh --describe。
    6. JMX 指标叫什么? → records-lag-max。
    7. RocketMQ 怎么看? → mqadmin consumerProgress 的 Diff Total。
    8. RabbitMQ 看什么? → messages_ready / messages_unacknowledged。
    9. ready 高说明什么? → 消费能力不足。
    10. unacked 高说明什么? → 消费者卡住/预取过多。
    11. 第一反应加消费者对吗? → 不一定。
    12. 为什么? → 受分区数限制,瓶颈可能在下游。
    13. Kafka 消费者上限? → 分区数。
    14. RocketMQ 呢? → 读队列数。
    15. RabbitMQ 呢? → 无硬上限,受队列/prefetch 影响。
    16. 加消费者后更慢? → 下游被打满。
    17. 怎么提单条吞吐? → 批量、异步、优化 SQL/RPC。
    18. Kafka 批量参数? → max.poll.records。
    19. RocketMQ 批量参数? → consumeMessageBatchMaxSize。
    20. RabbitMQ 呢? → prefetch / batchSize。
    21. 消费停住怎么查? → 线程栈、日志、Rebalance 记录。
    22. 毒消息特征? → 单分区 lag 不动、重复异常。
    23. 怎么处理毒消息? → 跳过/死信,留证据补偿。
    24. Kafka 怎么跳过? → seek 或死信 topic。
    25. RocketMQ 呢? → 重试耗尽进 %DLQ%。
    26. RabbitMQ 呢? → reject(requeue=false) 进 DLX。
    27. Rebalance 风暴原因? → max.poll.interval 超时。
    28. 怎么缓解? → 减小批量、异步化、调大间隔。
    29. Rebalance 对 lag 影响? → 消费停摆、lag 尖峰。
    30. 分区不够怎么办? → 扩分区/扩队列/临时转存。
    31. 扩分区有什么代价? → key 映射变化、顺序破坏。
    32. 同 key 顺序会怎样? → 可能落到不同分区。
    33. 历史消息会迁移吗? → 不会。
    34. RocketMQ 扩队列呢? → 新队列从最新位点开始。
    35. 临时转存怎么做? → 搬运消费者 + 多分区临时 topic。
    36. 风险是什么? → 重复、顺序、容量。
    37. 生产端能做什么? → 限流、合并、削峰。
    38. 能直接重置 offset 吗? → 会丢消息,慎用。
    39. 什么情况可以丢? → 日志/埋点等可丢数据。
    40. 降级怎么做? → 关非核心消费、异步化、限流。
    41. 积压会丢消息吗? → TTL/队列上限/磁盘满会。
    42. 积压会重复吗? → 重放/Rebalance 会。
    43. 顺序消费积压怎么办? → 不能加消费者,修毒消息/死信。
    44. 怎么预防积压? → 容量规划、压测、lag 告警。
    45. 告警怎么设? → 绝对值 + 增速 + 持续时长。
    46. 自动扩缩容? → KEDA 按 lag 扩 Pod。
    47. 扩 Pod 就够吗? → 还要分区数和下游支撑。
    48. 积压恢复后注意什么? → 重复、下游压力、顺序。
    49. 怎么复盘? → 根因、容量缺口、告警时效。
    50. 面试怎么总结? → 算数 → 三类定位 → 扩容上限 → 提吞吐 → 应急顺序 → 长期容量。
  • 生产案例/取舍(示例,替换成你的项目):

    • 大促流量翻 5 倍,Kafka 3 分区、已开 6 个消费者,加实例无效;扩到 12 分区后吞吐线性提升,但同 key 顺序受影响,改为按业务接受局部乱序。
    • 某分区 lag 一直不动,日志里同一条脏数据反复反序列化失败;跳过并投死信,恢复后补偿。
    • 消费批次调大后单批处理超过 max.poll.interval,频繁 Rebalance;减小批量 + 异步化,恢复稳定。
    • DB 慢查询导致消费 RT 从 20ms 涨到 2s,加消费者把 DB 打挂;先加索引 + 限流,再扩容。
    • RabbitMQ prefetch=1000,unacked 堆到 10 万,消费端频繁超时;降到 50 后恢复。
    • 顺序消费某条失败挂起队列,积压 200 万;转死信 + 人工修复,队列恢复。
    • 积压 1 亿、分区只有 3 个,起搬运消费者转到 30 分区临时 topic,2 小时清空;期间重复由幂等兜住。
    • 运维直接重置 offset 到 latest,丢了 30 万条订单消息;之后禁止无审批重置。
    • 消费者实例假死但心跳正常,lag 缓慢上涨;加业务健康检查 + 消费 TPS 告警。
    • 批量导入 500 万条,生产端限流 + 分片,避免一次性打爆。
    • 大促前按峰值 3 倍压测消费者,提前扩分区与实例,活动期间 lag 平稳。
    • 取舍:扩消费者换吞吐,代价是下游压力与 Rebalance;扩分区换并行,代价是顺序与迁移;临时转存换速度,代价是重复与复杂度;限流换稳定,代价是上游体验;丢弃换止血,代价是数据。
  • 易错点:

    • 认为加消费者一定能解决积压。
    • 认为消费者可以超过分区数。
    • 认为扩分区没有副作用。
    • 认为扩分区后历史消息会重新分布。
    • 认为 RocketMQ 扩队列能立刻分担历史积压。
    • 认为 lag 高就是消费者不够。
    • 认为 lag 不降一定是消费者问题。
    • 认为 messages_ready 和 unacked 是一回事。
    • 认为 prefetch 越大吞吐越高。
    • 认为批量越大越好,忽略 max.poll.interval。
    • 认为 Rebalance 不影响消费。
    • 认为毒消息会自动跳过。
    • 认为无限重试能解决脏数据。
    • 认为重置 offset 是安全的止血手段。
    • 认为积压只会延迟不会丢。
    • 认为积压期间 TTL 不会生效。
    • 认为积压重放不会重复。
    • 认为顺序消费积压可以靠加消费者解决。
    • 认为下游慢可以靠加消费者扛。
    • 认为扩实例能突破分区限制。
    • 认为临时转存没有重复风险。
    • 认为搬运消费者可以做业务逻辑。
    • 认为生产端限流不影响业务。
    • 认为降级不需要开关。
    • 认为 lag 告警只看绝对值就够。
    • 认为积压恢复后不需要观察。
    • 认为积压是运维问题,不是容量问题。
    • 认为压测过就不需要容量规划。
  • 30 秒口述稿:

积压就是消费速率持续低于生产速率。先算三个数:lag 有多少、生产 TPS 多少、消费 TPS 多少,算出清空时间,再看 lag 曲线属于哪类:突发流量、消费变慢、还是消费停住。消费停住通常是毒消息、Rebalance 风暴或实例假死,要先恢复消费;消费变慢多半是下游 DB/RPC 或 GC,先优化再加机器。扩容有硬上限,Kafka 消费者数不能超过分区数,RocketMQ 受读队列数限制,RabbitMQ 受 prefetch 和队列影响。所以顺序是:扩消费者、提批量、优化下游、生产限流/降级,分区不够才考虑扩分区或临时转存,最后才是跳过或丢弃。扩分区会破坏同 key 顺序,重置 offset 会丢消息,这两个要特别谨慎。长期靠容量规划、压测和 lag 告警。

  • 3 分钟展开顺序:结论(消费速率 < 生产速率)→ 三个数算清空时间 → 三类 lag 曲线定位 → 三件套指标(lag / Diff Total / ready+unacked)→ 扩容的硬上限 → 提单条吞吐的手段 → 消费停住的四类原因 → 应急手段的顺序与代价 → 扩分区/临时转存的风险 → 与丢消息、重复、顺序的联动 → 长期容量治理与告警。