消息队列 / 系统课时

演练重复与乱序故障

演练重复与乱序故障

本课把“重复”和“乱序”变成可复现的实验:先通过代理让确认返回超时,制造生产请求重试,再并发发送同一订单的状态事件,最后分别用生产端幂等、固定消息键和业务顺序约束验证治理效果。

学习目标

  • 能构造确认不可达导致的超时重试场景,并区分“客户端失败”与“Broker 已写入”
  • 能用消息键、分区和 offset 判断同一业务实体的事件顺序
  • 能验证生产端幂等、顺序约束与业务去重分别解决什么问题

构造确认不可达与重试

“Broker 已写入、Producer 没拿到确认”才是重复演练的关键。单纯执行 send 和 flush 只能证明正常发送,不能证明发生过重试。本实验在 Producer 与 Kafka 之间加入 Toxiproxy,让返回确认在代理处超时;客户端会把请求视为未完成并进入重试流程,而 Broker 可能已经接受过第一份记录。

先把 Kafka 暴露地址放到代理后,再运行故障注入命令。<KAFKA_HOST>、<PORT>、<PROXY_PORT> 使用测试环境实际值。

bash
curl -X POST http://127.0.0.1:8474/proxies -H 'Content-Type: application/json' -d '{"name":"kafka-proxy","listen":"0.0.0.0:<PROXY_PORT>","upstream":"<KAFKA_HOST>:<PORT>"}'
curl -X POST http://127.0.0.1:8474/proxies/kafka-proxy/toxics -H 'Content-Type: application/json' -d '{"name":"drop-ack-path","type":"timeout","stream":"downstream","toxicity":1.0,"attributes":{"timeout":1000}}'

预期结果:

text
代理创建成功,并在 kafka-proxy 上出现名为 drop-ack-path 的 downstream timeout 故障注入。

故障注入保持开启。为了真正观察重复写入风险,第一轮不要启用幂等生产者;否则 Kafka 的生产端幂等机制可能把重试造成的重复抑制掉。下面只保留一个主发送路径,并把 request.timeout.ms 与 delivery.timeout.ms 调小,便于在实验中观察超时边界。

java
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;
import java.util.Properties;

public class ProducerFailureDrill {
    public static void main(String[] args) throws Exception {
        Properties props = new Properties();
        props.put("bootstrap.servers", "127.0.0.1:<PROXY_PORT>");
        props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        props.put("enable.idempotence", "false");
        props.put("acks", "all");
        props.put("retries", "5");
        props.put("request.timeout.ms", "1000");
        props.put("delivery.timeout.ms", "5000");

        try (KafkaProducer<String, String> producer = new KafkaProducer<>(props)) {
            ProducerRecord<String, String> record =
                    new ProducerRecord<>("orders", "order-1001", "PAYMENT_CONFIRMED");

            try {
                producer.send(record).get();
                System.out.println("send acknowledged");
            } catch (Exception e) {
                // 客户端看到失败并不等于 Broker 没有写入,这是本实验要验证的边界。
                System.out.println("client result: " + e.getClass().getSimpleName());
            }
        }
    }
}

预期结果:

text
client result: TimeoutException

随后在 Kafka 中按业务键检查 order-1001。实验重点不是固定出现几条记录,而是确认“客户端超时”与“Broker 实际写入”可以同时发生;在幂等关闭的情况下,重试还可能让同一业务消息出现多条记录。确认这一点后,再开启 enable.idempotence=true 重复相同实验,对照消息数量变化。需要注意,生产端幂等只能抑制 Kafka Producer 重试带来的重复写入风险,并不等于消费者或业务处理天然幂等。

![确认不可达、重试与重复记录的演练时序]

构造并发发送导致的乱序

重复和乱序要分开验证。幂等生产者解决的是同一生产会话中的重复写入风险,不负责把并发产生的业务事件重新排序。对同一个订单同时提交 PAID 和 SHIPPED 时,两个线程谁先调用 send,就可能决定它们进入 Producer 缓冲的先后;即便两个事件最终落在同一分区,也只能保证它们按 offset 形成一个确定顺序,不能替业务判断哪个状态本应先发生。

下面用两个线程并发提交同一个 key 的事件。实验连续运行多次,记录每次的发送顺序,再从同一分区的 offset 顺序确认实际记录顺序。

java
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;
import java.util.Properties;
import java.util.concurrent.CountDownLatch;

public class OrderingDrill {
    public static void main(String[] args) throws Exception {
        Properties props = new Properties();
        props.put("bootstrap.servers", "<HOST>:<PORT>");
        props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        props.put("enable.idempotence", "true");
        props.put("acks", "all");

        try (KafkaProducer<String, String> producer = new KafkaProducer<>(props)) {
            CountDownLatch start = new CountDownLatch(1);

            Thread paid = new Thread(() -> sendWhenReleased(start, producer, "PAID"));
            Thread shipped = new Thread(() -> sendWhenReleased(start, producer, "SHIPPED"));
            paid.start();
            shipped.start();
            start.countDown();
            paid.join();
            shipped.join();
            producer.flush();
        }
    }

    private static void sendWhenReleased(
            CountDownLatch start,
            KafkaProducer<String, String> producer,
            String state) {
        try {
            start.await();
            producer.send(new ProducerRecord<>("orders", "order-1001", state));
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

预期结果:

text
同一个 key 的两条记录都进入 orders 的同一分区,但多次实验可能出现 PAID→SHIPPED,也可能出现 SHIPPED→PAID。
同一分区内最终仍按 offset 给出唯一顺序;业务顺序是否正确取决于生产端的事件生成约束。

因此,真正的治理边界是“同一实体只允许按明确顺序产生事件”。常见做法是让同一实体固定使用相同消息键,从而进入同一分区;同时在应用侧限制同一实体的无约束并发发送。若业务状态只能向前推进,还应在消费者侧校验状态转移,例如拒绝已经低于当前状态的旧事件。这里要区分两层语义:Kafka 保证同一分区内的记录有序,而业务必须负责定义“什么顺序才是正确顺序”。

验证治理是否生效

有效演练要做对照,而不是只看日志里有没有报错。第一组保留故障条件,记录客户端结果、同一业务键的消息数量、分区和 offset;第二组关闭故障注入并保持其他配置不变,再重复相同实验;第三组在相同故障条件下开启生产端幂等,对照重复记录数量。这样才能把故障来源与治理效果对应起来。

重点观察四项证据:Producer 是否发生超时或重试、Broker 中同一业务键有多少条记录、同一分区中的 offset 顺序,以及消费者最终业务状态。对于重复处理风险,除了生产端幂等,还要验证消费者或业务层的幂等键;对于乱序风险,则要验证状态机是否拒绝不合法的状态回退。

最终应明确区分三类故障:确认不可达造成的生产重试、并发事件生成造成的顺序不确定,以及消费者缺少业务幂等造成的重复处理。前两者分别对应生产端的传输语义与顺序约束,最后一类必须由业务层补上最终一致的处理边界。

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

目录与阅读设置

记录一个想法

演练重复与乱序故障

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

登录哪都通