消息队列 / 系统课时

使用 Pause 与 Resume 做背压

使用 Pause 与 Resume 做背压

当下游数据库、HTTP 服务或线程池暂时处理不过来时,目标不是让消费者退出组,而是暂缓指定分区继续取数,同时保持 Poll 循环活跃。pause() 与 resume() 可以把背压限制在当前消费者和当前分区,避免用重启制造额外 Rebalance。

学习目标

  • 理解 pause()、resume() 与消费组成员关系之间的边界。
  • 使用高低水位控制拉取节奏,并持续调用 poll()。
  • 正确处理已拉取记录、Offset 提交与 Rebalance 后的暂停状态。

Pause 不是停掉消费者

pause(Collection<TopicPartition>) 暂停的是指定已分配分区的后续取数。被暂停后,未来的 poll() 不再返回这些分区的新记录,但订阅关系和分区归属并不会因此改变,也不会因为调用 pause() 本身触发 Rebalance。

这和“停止调用 poll()”完全不同。消费组仍然要求消费者按时进入 Poll 循环;如果两次 poll() 的间隔超过 max.poll.interval.ms,消费者可能被视为失去处理能力并引发重新分配。背压期间应继续短周期 Poll,只是让暂停分区暂时不再补充新记录。

还要注意一个边界:pause() 只影响之后的 Poll,已经返回到应用内存中的记录不会被 Kafka 收回。因此真正的限流对象应是“Kafka 拉取 + 本地待处理队列”这条链路,而不是等内存已经堆满后才暂停。

Pause 与 Resume 背压控制链路

用高低水位控制拉取

最实用的策略是设置两个阈值:待处理记录达到高水位时暂停拉取,下降到低水位时再恢复。两个阈值不要相同,否则队列在临界点附近抖动时会频繁 Pause/Resume。

下面示例假设 Java 工程已引入与集群兼容的 org.apache.kafka:kafka-clients。它把 Poll 到的记录先放入本地缓冲区,每轮只处理少量记录,从而保证消费线程能持续回到 poll();Offset 只提交到已经处理完成的位置。

java
import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.clients.consumer.ConsumerRebalanceListener;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.KafkaConsumer;
import org.apache.kafka.clients.consumer.OffsetAndMetadata;
import org.apache.kafka.common.TopicPartition;
import org.apache.kafka.common.serialization.StringDeserializer;

import java.time.Duration;
import java.util.ArrayDeque;
import java.util.Collection;
import java.util.Collections;
import java.util.Deque;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

public class PauseResumeBackpressureDemo {
    private static final int HIGH_WATERMARK = 200;
    private static final int LOW_WATERMARK = 50;
    private static final int PROCESS_PER_LOOP = 10;

    public static void main(String[] args) {
        String bootstrapServers = args.length > 0 ? args[0] : "localhost:9092";
        String topic = args.length > 1 ? args[1] : "orders";
        String groupId = args.length > 2 ? args[2] : "orders-worker";

        Properties props = new Properties();
        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, bootstrapServers);
        props.put(ConsumerConfig.GROUP_ID_CONFIG, groupId);
        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, "false");
        props.put(ConsumerConfig.MAX_POLL_RECORDS_CONFIG, "50");

        Deque<ConsumerRecord<String, String>> buffer = new ArrayDeque<>();

        try (KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props)) {
            consumer.subscribe(Collections.singletonList(topic), new ConsumerRebalanceListener() {
                @Override
                public void onPartitionsRevoked(Collection<TopicPartition> partitions) {
                    // 丢弃尚未处理的本地记录,让新 owner 从已提交 Offset 重新获取。
                    buffer.clear();
                    System.out.println("revoked=" + partitions);
                }

                @Override
                public void onPartitionsAssigned(Collection<TopicPartition> partitions) {
                    System.out.println("assigned=" + partitions);
                }
            });

            while (true) {
                ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(100));
                records.forEach(buffer::addLast);

                Set<TopicPartition> assignment = consumer.assignment();
                if (buffer.size() >= HIGH_WATERMARK
                        && !assignment.isEmpty()
                        && consumer.paused().isEmpty()) {
                    consumer.pause(assignment);
                    System.out.println("PAUSE buffer=" + buffer.size() + " partitions=" + assignment);
                }

                Map<TopicPartition, OffsetAndMetadata> processedOffsets = new HashMap<>();
                for (int i = 0; i < PROCESS_PER_LOOP && !buffer.isEmpty(); i++) {
                    ConsumerRecord<String, String> record = buffer.removeFirst();
                    process(record);
                    TopicPartition tp = new TopicPartition(record.topic(), record.partition());
                    processedOffsets.put(tp, new OffsetAndMetadata(record.offset() + 1));
                }

                if (!processedOffsets.isEmpty()) {
                    consumer.commitSync(processedOffsets);
                }

                if (buffer.size() <= LOW_WATERMARK && !consumer.paused().isEmpty()) {
                    Set<TopicPartition> paused = new HashSet<>(consumer.paused());
                    consumer.resume(paused);
                    System.out.println("RESUME buffer=" + buffer.size() + " partitions=" + paused);
                }
            }
        }
    }

    private static void process(ConsumerRecord<String, String> record) {
        try {
            // 模拟可被拆成短片执行的下游处理,避免一次处理长期占住消费线程。
            Thread.sleep(20);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new RuntimeException("processing interrupted", e);
        }
    }
}

预期输出:当生产速度高于示例中的处理速度、缓冲区跨过阈值时,会看到类似状态切换;分区列表与缓冲区数值以现场为准。

text
assigned=<PARTITIONS>
PAUSE buffer=<VALUE> partitions=<PARTITIONS>
RESUME buffer=<VALUE> partitions=<PARTITIONS>

Offset 与 Rebalance 要一起设计

背压不能只看“是否暂停”,还要看 Offset 是否已经越过真正处理完成的位置。异步处理场景尤其不要开启自动提交后就把 Poll 到的记录直接塞进线程池,否则提交位置可能领先于下游完成进度,进程故障时会造成未处理记录被跳过。

示例在 Rebalance 撤销分区时清空未处理缓冲区,让这些记录由新 owner 从已提交位置重放。这会牺牲一部分重复处理来换取安全边界。生产系统若要减少重放,可以按分区维护任务队列和连续完成 Offset,并在撤销回调中停止接收、等待或取消该分区任务,再由消费线程提交安全位置。

Kafka 的暂停状态不会跨 Rebalance 保留。发生重新分配后,应根据新的 assignment()、当前队列水位和下游健康度重新决定哪些分区需要暂停,而不是假设旧状态仍有效。

什么时候该恢复拉取

恢复条件最好同时考虑本地队列和下游健康度。仅凭一个瞬时成功请求就 resume(),很容易让流量立即再次压满下游。实践中通常使用高低水位形成滞回,并为暂停持续时间、队列长度和消费 Lag 建立监控。

对于不可预测的长耗时 I/O,更稳妥的实现是把处理移到工作线程,但所有 KafkaConsumer API 仍由消费线程调用,并把“处理完成的 Offset”通过线程安全队列送回消费线程提交。这样既能持续 Poll,又不会违反 KafkaConsumer 非线程安全的约束。

按自己的节奏,确认真正理解。

目录与阅读设置

记录一个想法

使用 Pause 与 Resume 做背压

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通