主流消息队列对比：Kafka vs RabbitMQ vs RocketMQ

@淡 定2025-12-27 8:31

主流消息队列深度对比：Kafka vs RabbitMQ vs RocketMQ

一、引言

消息队列作为分布式系统的核心组件，承担着解耦、削峰、异步通信的重要职责。在选择消息队列时，需要综合考虑业务需求、技术栈、性能要求、可靠性要求等多方面因素。本文将从架构设计、性能特性、可靠性机制、功能特性、适用场景等多个维度，对Kafka、RabbitMQ和RocketMQ进行深度对比分析。

二、核心维度对比表（增强版）

对比维度 Kafka RabbitMQ RocketMQ
开源公司 LinkedIn（现归Confluent） Pivotal（现归VMware） 阿里巴巴
开发语言 Scala + Java Erlang Java
最新稳定版 3.7.0（2024） 3.13.0（2024） 5.2.0（2024）
协议支持 自定义协议 AMQP 0-9-1, AMQP 1.0, MQTT, STOMP 自定义协议
核心架构 分区模型，分布式流处理平台 交换器+队列模型，基于AMQP NameServer+Broker，分布式消息中间件
吞吐量 百万级QPS（单Broker支持50万+写入） 万级QPS（单节点支持1-2万写入） 十万级到百万级QPS（单Broker支持10万+写入）
延迟 毫秒级（默认异步刷盘，约10ms） 微秒级到毫秒级（最佳约50μs） 毫秒级（同步刷盘约1ms，异步刷盘约5ms）
消息大小限制 默认1MB（可配置，最大100MB） 默认128MB（可配置） 默认4MB（可配置，最大64MB）
消息可靠性 基于副本+ACK机制 基于事务+确认机制 基于同步/异步刷盘+复制+事务消息
顺序消息 分区内顺序 单队列顺序 全局顺序/分区顺序
事务消息 事务生产者 AMQP事务 完整二阶段事务消息
延迟消息 基于时间轮（精确延迟） 插件实现（18个固定级别） 18个固定级别或精确延迟（4.x+）
死信队列 支持 支持 支持
消息轨迹 支持（需配置Kafka Eagle） 不支持（需插件） 支持（完整消息轨迹）
消息过滤 基于消费组 基于Exchange路由 基于Tag+SQL92过滤
批量消息 支持 支持 支持
管理界面 基础（Kafka Manager, Kafka Eagle） 丰富（Web UI） 完善（RocketMQ Console）
监控能力 中等（JMX + Prometheus） 强（内置监控 + Prometheus） 强（内置监控 + Prometheus + Grafana）
生态系统 强（Flume、Spark、Flink、ELK） 中等（Spring AMQP、Celery、Quartz） 强（Spring Cloud Stream、Dubbo、Sentinel）
社区活跃度 极高（GitHub 70k+ stars） 高（GitHub 13k+ stars） 高（GitHub 30k+ stars）
学习曲线 陡峭 平缓 中等
部署复杂度 高（需ZooKeeper或KRaft） 低 中等（需NameServer）
适用场景 日志收集、流处理、大数据分析 企业级应用、复杂路由、多协议支持 电商交易、金融支付、订单系统

三、深度技术原理详解

1. 架构设计深度解析

1.1 Kafka架构设计
核心组件

发送消息
存储消息
分为多个
副本同步
消费消息
协调管理
流处理
Producer
Broker Cluster
Topic
Partition
Replica
Consumer Group
ZooKeeper/KRaft
Kafka Streams

关键设计理念
  • 分区模型：每个Topic分为多个Partition，分布式存储在不同Broker上，支持水平扩展
  • 顺序I/O：消息按顺序写入Partition，利用磁盘顺序I/O的高性能特性
  • 零拷贝：使用sendfile系统调用，减少数据在内核态和用户态之间的拷贝
  • 批量处理：支持批量发送和消费，减少网络开销
  • 消费者组：每个Partition只能被一个消费者实例消费，保证消息有序性
存储结构
复制代码 
# Kafka存储结构
kafka-logs/
├── topic-0/
│   ├── 00000000000000000000.log  # 数据文件
│   ├── 00000000000000000000.index  # 索引文件
│   └── 00000000000000000000.timeindex  # 时间索引
└── topic-1/
    ├── 00000000000000000000.log
    ├── 00000000000000000000.index
    └── 00000000000000000000.timeindex
1.2 RabbitMQ架构设计
核心组件

发送消息
路由规则
存储消息
消费消息
隔离
监控管理
Producer
Exchange
Queue
Disk/Memory
Consumer
Virtual Host
Management UI

关键设计理念
  • AMQP协议：基于高级消息队列协议，支持多种消息模型
  • 交换器模型 ：支持4种Exchange类型，实现复杂路由
    • Direct：精确匹配Routing Key
    • Fanout：广播到所有绑定的队列
    • Topic：模糊匹配Routing Key（支持通配符）
    • Headers：基于消息头匹配
  • Erlang虚拟机：天然支持高并发和分布式，每个RabbitMQ节点都是独立的Erlang进程
  • 镜像队列：支持队列镜像，提高可靠性
存储结构
复制代码 
# RabbitMQ存储结构
/var/lib/rabbitmq/mnesia/
├── rabbit@node1/  # 节点数据
│   ├── msg_store_persistent/  # 持久化消息存储
│   ├── msg_store_transient/  # 临时消息存储
│   └── queues/  # 队列元数据
└── rabbit@node2/
    ├── msg_store_persistent/
    ├── msg_store_transient/
    └── queues/
1.3 RocketMQ架构设计
核心组件

发送消息
路由发现
存储消息
生成索引
消费消息
监控管理
Producer
NameServer Cluster
Broker Cluster
CommitLog
ConsumeQueue
Consumer
Console

关键设计理念
  • NameServer：轻量级命名服务，负责服务发现，无状态，可横向扩展
  • CommitLog：所有消息按顺序存储在统一的CommitLog文件中，实现顺序写入
  • ConsumeQueue：消息消费队列，存储消息在CommitLog中的偏移量和长度，作为索引文件
  • 零拷贝：使用mmap+sendfile机制，提高消息传输效率
  • 主从复制：支持同步复制和异步复制，保证数据可靠性
存储结构
复制代码 
# RocketMQ存储结构
store/
├── commitlog/  # 统一的消息存储文件
│   ├── 00000000000000000000  # 20GB大小的CommitLog文件
│   └── 00000000002000000000
├── consumequeue/  # 消费队列索引
│   └── topic1/  # 按Topic划分
│       └── 0/  # 按QueueId划分
│           ├── 00000000000000000000  # 30W条/文件
│           └── 00000000000003000000
└── index/  # 消息索引，支持按Key查询
    └── 00000000000000000000

2. 性能原理深度分析

2.1 吞吐量对比
测试场景 Kafka RabbitMQ RocketMQ
单Broker写入 50万+ QPS 1-2万 QPS 10万+ QPS
单Broker读取 100万+ QPS 2-3万 QPS 20万+ QPS
集群写入 100万+ QPS 5-10万 QPS 50万+ QPS
集群读取 200万+ QPS 10-15万 QPS 100万+ QPS
性能差异根因
  • Kafka：顺序I/O + 零拷贝 + 批量处理，充分利用磁盘性能
  • RabbitMQ：Erlang进程调度开销 + 消息路由开销，单节点性能受限
  • RocketMQ：CommitLog顺序写入 + ConsumeQueue索引机制，平衡了性能和可靠性
2.2 延迟对比
测试场景 Kafka RabbitMQ RocketMQ
异步刷盘 约10ms 约50μs 约5ms
同步刷盘 约100ms 约1ms 约1ms
批量发送 约5ms 约200μs 约2ms
单条发送 约20ms 约100μs 约10ms
延迟优化策略
  • Kafka：使用更大的批量大小、异步发送、调整ACK级别
  • RabbitMQ ：使用持久化队列时，调整queue.sync_mode参数
  • RocketMQ：根据业务需求选择同步/异步刷盘和复制策略

3. 可靠性机制深度解析

3.1 持久化机制
消息队列 持久化方式 可靠性级别 性能影响
Kafka 顺序写入磁盘，支持同步/异步刷盘 高（副本数≥3） 异步刷盘性能影响小，同步刷盘影响大
RabbitMQ 消息写入磁盘，支持队列持久化和消息持久化 高 持久化会降低约50%性能
RocketMQ CommitLog顺序写入，支持同步/异步刷盘 极高 同步刷盘性能影响约30%，异步刷盘影响小
3.2 复制机制
消息队列 复制方式 一致性保证 适用场景
Kafka 基于ISR（In-Sync Replicas）的异步复制 最终一致 大数据、流处理
RabbitMQ 镜像队列，基于主从复制 强一致（主从同步） 企业级应用
RocketMQ 同步复制/异步复制 强一致（同步复制）/最终一致（异步复制） 金融支付、电商交易
3.3 确认机制
消息队列 生产者确认 消费者确认 事务支持
Kafka ACK机制（0、1、all） 自动提交/手动提交 事务生产者
RabbitMQ Publisher Confirm Consumer Ack AMQP事务
RocketMQ Sync/Async Send Result 自动提交/手动提交 二阶段事务消息
3.4 事务消息深度对比
Kafka事务消息
  • 实现原理：基于事务ID和幂等性写入，支持多分区事务
  • 适用场景：需要原子性写入多个分区的场景
  • 局限性：不支持事务回滚，仅保证生产者的事务性
RabbitMQ事务消息
  • 实现原理 ：基于AMQP事务机制，通过tx.select()、tx.commit()、tx.rollback()实现
  • 适用场景：需要严格事务保证的场景
  • 局限性：性能极低，建议使用Publisher Confirm替代
RocketMQ事务消息
  • 实现原理：完整的二阶段提交，支持事务回滚
  • 流程 ：
    1. 发送半消息（Half Message）
    2. 执行本地事务
    3. 提交或回滚事务
    4. 定时回查本地事务状态
  • 适用场景：金融支付、订单处理等核心业务
  • 优势：性能高，可靠性强，适合高并发场景

4. 功能特性深度对比

4.1 顺序消息
消息队列 实现方式 顺序性保证 性能影响
Kafka 分区内顺序，一个消费者组内每个Partition只能被一个消费者消费 分区内严格顺序 无影响
RabbitMQ 单队列顺序，一个队列只能被一个消费者消费 全局严格顺序 性能降低约50%
RocketMQ 全局顺序（单Partition）或分区顺序 全局/分区严格顺序 全局顺序性能降低约80%，分区顺序无影响
4.2 延迟消息
消息队列 实现方式 精度 最大延迟
Kafka 基于时间轮算法，自定义实现 毫秒级 无限制
RabbitMQ 基于插件rabbitmq_delayed_message_exchange 固定18个级别（1s-2h） 2小时
RocketMQ 基于定时器+延迟队列 18个固定级别或精确延迟（4.x+） 无限制
4.3 消息过滤
消息队列 过滤方式 灵活性 性能影响
Kafka 基于消费组，在消费者端过滤 低 高（网络传输浪费）
RabbitMQ 基于Exchange路由规则，在Broker端过滤 中 低
RocketMQ Tag过滤（Broker端）+ SQL92过滤（消费者端） 高 低（Tag过滤）/中（SQL92过滤）

四、实际应用案例

1. Kafka应用案例

案例1：ELK日志收集系统
  • 业务场景：收集分布式系统的日志，进行实时分析和监控
  • 架构设计：Filebeat → Kafka → Logstash → Elasticsearch → Kibana
  • 规模：每天处理10TB日志，峰值QPS 50万
  • 优势：高吞吐量，适合处理海量日志，与ELK生态集成良好
案例2：实时流处理平台
  • 业务场景：实时分析用户行为，进行个性化推荐
  • 架构设计：用户行为 → Kafka → Flink → Redis/MySQL
  • 规模：每秒处理10万+事件，延迟要求500ms以内
  • 优势：支持流处理，与Flink集成紧密，低延迟

2. RabbitMQ应用案例

案例1：企业级OA系统
  • 业务场景：内部系统通信，工作流编排
  • 架构设计：OA系统 → RabbitMQ → 各业务系统
  • 规模：每天处理100万条消息，峰值QPS 5000
  • 优势：支持多种Exchange类型，复杂路由能力强，可靠性高
案例2：物联网设备消息处理
  • 业务场景：处理物联网设备发送的传感器数据
  • 架构设计：IoT设备 → MQTT Broker → RabbitMQ → 数据处理系统
  • 规模：连接10万+设备，每秒处理2万条消息
  • 优势：支持MQTT协议，适合物联网场景

3. RocketMQ应用案例

案例1：电商订单系统
  • 业务场景：处理订单创建、库存扣减、支付处理等核心业务
  • 架构设计：订单系统 → RocketMQ → 库存系统/支付系统/物流系统
  • 规模：峰值QPS 50万，每天处理1000万+订单
  • 优势：支持事务消息、顺序消息，高可靠高并发
案例2：金融支付系统
  • 业务场景：处理转账、结算、对账等金融业务
  • 架构设计：支付系统 → RocketMQ → 清算系统/对账系统
  • 规模：峰值QPS 20万，要求零数据丢失
  • 优势：事务消息可靠，支持消息轨迹，适合金融场景

五、代码示例

1. Kafka代码示例

生产者代码
java 复制代码 
// Kafka生产者配置
Properties props = new Properties();
props.put("bootstrap.servers", "localhost:9092");
props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
props.put("acks", "all"); // 最高可靠性
props.put("batch.size", 16384); // 批量大小
props.put("linger.ms", 1); // 延迟发送

// 创建生产者
KafkaProducer<String, String> producer = new KafkaProducer<>(props);

// 发送消息
ProducerRecord<String, String> record = new ProducerRecord<>("topic1", "key1", "value1");
try {
    // 同步发送
    RecordMetadata metadata = producer.send(record).get();
    System.out.println("消息发送成功：" + metadata.topic() + "-" + metadata.partition() + "-" + metadata.offset());
} catch (Exception e) {
    e.printStackTrace();
}

// 关闭生产者
producer.close();
消费者代码
java 复制代码 
// Kafka消费者配置
Properties props = new Properties();
props.put("bootstrap.servers", "localhost:9092");
props.put("group.id", "consumer-group-1");
props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
props.put("enable.auto.commit", "true"); // 自动提交偏移量
props.put("auto.commit.interval.ms", "1000"); // 自动提交间隔

// 创建消费者
KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);

// 订阅主题
consumer.subscribe(Arrays.asList("topic1"));

// 消费消息
while (true) {
    ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(100));
    for (ConsumerRecord<String, String> record : records) {
        System.out.printf("收到消息：topic=%s, partition=%d, offset=%d, key=%s, value=%s%n",
                record.topic(), record.partition(), record.offset(), record.key(), record.value());
    }
}

2. RabbitMQ代码示例

生产者代码
java 复制代码 
// 连接工厂配置
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("localhost");
factory.setUsername("guest");
factory.setPassword("guest");

// 创建连接和通道
Connection connection = factory.newConnection();
Channel channel = connection.createChannel();

// 声明交换机和队列
String exchangeName = "direct-exchange";
String queueName = "queue1";
String routingKey = "key1";

channel.exchangeDeclare(exchangeName, BuiltinExchangeType.DIRECT, true);
channel.queueDeclare(queueName, true, false, false, null);
channel.queueBind(queueName, exchangeName, routingKey);

// 发送持久化消息
byte[] messageBodyBytes = "Hello RabbitMQ".getBytes();
channel.basicPublish(exchangeName, routingKey, MessageProperties.PERSISTENT_TEXT_PLAIN, messageBodyBytes);

// 关闭资源
channel.close();
connection.close();
消费者代码
java 复制代码 
// 连接工厂配置
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("localhost");
factory.setUsername("guest");
factory.setPassword("guest");

// 创建连接和通道
Connection connection = factory.newConnection();
Channel channel = connection.createChannel();

// 声明队列
String queueName = "queue1";
channel.queueDeclare(queueName, true, false, false, null);

// 消费消息
DeliverCallback deliverCallback = (consumerTag, delivery) -> {
    String message = new String(delivery.getBody(), "UTF-8");
    System.out.println("收到消息：" + message);
    // 手动确认消息
    channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
};

// 启动消费者（手动确认）
channel.basicConsume(queueName, false, deliverCallback, consumerTag -> {});

3. RocketMQ代码示例

生产者代码
java 复制代码 
// 生产者配置
DefaultMQProducer producer = new DefaultMQProducer("producer-group");
producer.setNamesrvAddr("localhost:9876");
producer.setRetryTimesWhenSendFailed(3); // 发送失败重试次数

// 启动生产者
producer.start();

// 创建消息
Message message = new Message("topic1", "tag1", "key1", "Hello RocketMQ".getBytes());

// 发送同步消息
try {
    SendResult sendResult = producer.send(message);
    System.out.println("消息发送成功：" + sendResult);
} catch (Exception e) {
    e.printStackTrace();
}

// 关闭生产者
producer.shutdown();
消费者代码
java 复制代码 
// 消费者配置
DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("consumer-group");
consumer.setNamesrvAddr("localhost:9876");
consumer.subscribe("topic1", "tag1"); // 订阅主题和Tag

// 注册消息监听器
consumer.registerMessageListener((MessageListenerConcurrently) (msgs, context) -> {
    for (MessageExt msg : msgs) {
        System.out.printf("收到消息：topic=%s, tag=%s, key=%s, body=%s%n",
                msg.getTopic(), msg.getTags(), msg.getKeys(), new String(msg.getBody()));
    }
    // 返回消费成功
    return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
});

// 启动消费者
consumer.start();
System.out.println("消费者启动成功");

五、最新特性对比（2024）

1. Kafka 3.7.0新特性

  • KRaft模式稳定版：内置协调器，不再依赖ZooKeeper
  • 分层存储：支持将旧数据迁移到低成本存储（如S3）
  • 增强的流处理能力：Kafka Streams支持更多窗口函数
  • 改进的安全性：支持SASL/OAUTHBEARER认证

2. RabbitMQ 3.13.0新特性

  • 增强的MQTT 5.0支持：完整支持MQTT 5.0协议
  • 改进的流处理能力：RabbitMQ Streams支持更多操作
  • 增强的监控能力：与Prometheus集成更紧密
  • 改进的集群管理：支持自动集群配置

3. RocketMQ 5.2.0新特性

  • 增强的事务消息：支持分布式事务协调
  • 精确延迟消息：支持毫秒级精确延迟
  • 增强的消息轨迹：支持更详细的消息流转信息
  • 改进的性能：单Broker支持更高的吞吐量

六、选型决策框架

1. 选型决策树

渲染错误: Mermaid 渲染失败: No diagram type detected matching given configuration for text: decision TD A开始选型 --> B{业务场景?} B -->|日志收集/流处理| C选择Kafka B -->|企业级应用/复杂路由| D选择RabbitMQ B -->|电商/金融核心业务| E选择RocketMQ B -->|其他场景| F{技术栈?} F -->|Scala/Java大数据栈| C F -->|Erlang/AMQP| D F -->|Java/阿里生态| E F -->|其他| G{性能要求?} G -->|百万级QPS| C G -->|万级QPS| D G -->|十万级QPS| E G -->|不确定| H{可靠性要求?} H -->|极高（零丢失）| E H -->|高| D H -->|一般| C

2. 选型评分表

评分项（权重） Kafka RabbitMQ RocketMQ
吞吐量（30%） 10 5 8
延迟（20%） 7 10 8
可靠性（20%） 8 9 10
功能丰富度（15%） 7 8 10
易用性（10%） 6 9 7
生态系统（5%） 10 7 8
总分 8.3 7.8 8.9

七、部署与监控最佳实践

1. Kafka部署最佳实践

  • 硬件配置：64GB内存，16核CPU，多块SSD磁盘（RAID 10）

  • 集群规模：建议3-5个Broker，副本数3

  • 关键配置 ：

    properties 复制代码 
    # 优化吞吐量
num.io.threads=16
num.network.threads=8
log.flush.interval.messages=10000
log.flush.interval.ms=1000

# 优化可靠性
min.insync.replicas=2
default.replication.factor=3

  • 监控工具：Kafka Eagle + Prometheus + Grafana

2. RabbitMQ部署最佳实践

  • 硬件配置：32GB内存，8核CPU，SSD磁盘

  • 集群规模：建议3个节点，使用镜像队列

  • 关键配置 ：

    erlang 复制代码 
    # 优化性能
vm_memory_high_watermark.absolute=16GB
disk_free_limit.absolute=5GB
queue_index_embed_msgs_below=4096

# 优化可靠性
queue.sync_mode=manual

  • 监控工具：RabbitMQ Management UI + Prometheus + Grafana

3. RocketMQ部署最佳实践

  • 硬件配置：64GB内存，16核CPU，多块SSD磁盘（分离CommitLog和ConsumeQueue）

  • 集群规模：建议3个NameServer，2个Broker（主从架构）

  • 关键配置 ：

    properties 复制代码 
    # 优化吞吐量
mapedFileSizeCommitLog=1073741824 # 1GB
deleteWhen=04
fileReservedTime=72

# 优化可靠性
flushDiskType=SYNC_FLUSH
flushCommitLogLeastPages=4

  • 监控工具：RocketMQ Console + Prometheus + Grafana

八、常见问题与解决方案

1. Kafka常见问题

问题 原因 解决方案
消息丢失 默认acks=1 + 异步刷盘 设置acks=all，副本数=3，同步刷盘
消息重复 消费者重复消费 实现幂等性消费，使用Kafka事务
分区倾斜 数据分布不均 使用一致性哈希分区，调整分区数
ZooKeeper依赖 旧版本依赖ZooKeeper 升级到Kafka 2.8+，使用KRaft模式

2. RabbitMQ常见问题

问题 原因 解决方案
性能瓶颈 Erlang进程调度开销 增加节点数，使用镜像队列，调整消息大小
内存溢出 消息堆积 设置合理的队列大小限制，使用死信队列
消息重复 消费者确认机制问题 实现幂等性消费，使用手动确认
分区丢失 节点故障 使用镜像队列，设置ha-mode=all

3. RocketMQ常见问题

问题 原因 解决方案
事务消息超时 本地事务执行时间过长 优化本地事务逻辑，增加事务超时时间
消息堆积 消费者消费速度慢 增加消费者实例数，优化消费逻辑
Broker压力大 写入速度过快 增加Broker节点数，调整刷盘策略
NameServer不可用 单节点故障 部署多个NameServer，客户端配置多个NameServer地址

九、总结

Kafka、RabbitMQ和RocketMQ各有优势，选型时需根据业务需求、技术栈、性能要求、可靠性要求等因素综合考虑：

  • Kafka：适合日志收集、流处理、大数据分析等场景，具有极高的吞吐量和良好的生态系统
  • RabbitMQ：适合企业级应用、复杂路由、多协议支持等场景，具有丰富的功能和良好的易用性
  • RocketMQ：适合电商交易、金融支付、订单系统等核心业务场景，具有高可靠性、高并发和丰富的企业级功能

随着技术的发展，各消息队列的功能边界逐渐模糊，但它们的核心定位仍然不同。理解各消息队列的核心设计理念和适用场景，是选择合适消息队列的关键。

在实际应用中，也可以结合使用多种消息队列，根据不同业务场景选择最合适的解决方案。例如，使用Kafka处理日志，使用RabbitMQ处理企业级应用通信，使用RocketMQ处理核心业务交易。

最后，无论选择哪种消息队列，都需要关注其部署、监控、运维等方面，确保系统的稳定运行。

相关推荐
此时不提桶，更待何时5 小时前
06-23-A-RabbitMQ生态集成详解
分布式·rabbitmq
m0_6464299710 小时前
RabbitMQ 核心知识总结（生产实战版）
分布式·rabbitmq
ClouGence14 小时前
开源数据库管理工具 CloudDM 4.4.0 发布，新增 Kafka、SAP HANA 数据源
数据库·kafka
RobinXYuan14 小时前
【Kafka 源码手记】01 从消息队列到 Event Streaming
kafka·源码阅读
此时不提桶，更待何时16 小时前
06-24-B-RabbitMQ面试与生产事故实战
分布式·面试·rabbitmq
此时不提桶，更待何时1 天前
06-17-A-RabbitMQ架构与存储原理详解
rabbitmq
阿里云云原生1 天前
RocketMQ for AI：基于 LiteTopic 的 Agent 异步通信架构与生产实践
rocketmq
nvd111 天前
深入剖析：GCP Pub/Sub 与 Apache Kafka 对消息处理延迟与消费者卡死的处理机制异同
分布式·kafka·apache
做个文艺程序员1 天前
MQ第03篇：RabbitMQ进阶实战：Topic路由+死信队列+延迟消息，SaaS订单超时取消完整方案
分布式·消息队列·rabbitmq·死信队列·延迟队列
此时不提桶，更待何时2 天前
06-18-A-RabbitMQ消息特性与消费机制详解
分布式·rabbitmq
热门推荐
01国内可直接用、免费额度/永久免费的大模型API清单（含 SiliconFlow、火山、阿里、智谱、百度、Kimi、DeepSeek、DMXAPI 等）02历年考研数学一、数学二、数学三真题试卷及答案PDF03GitHub 镜像站点04「全语录+省流版」邵艾伦 × 孙宇晨：聊风口、聊个人IP、聊年轻人如何抓住 AI 时代的机会05如何新建文件夹？ 电脑新建文件夹的4种方法06蜘蛛磁力 搜索引擎大全，如何使用蜘蛛磁力查找磁力链接07Windows 10/11 如何退出微软账户并改用本地账户登录（含找不到选项的解决方法）08Telegram APK 下载安装完整指南 — 2026年最新09轻量化AI渗透武器库｜ARTEX自主攻防系统、资产梳理、漏洞挖掘、链路分析全流程智能化落地10微信历史版本含下载地址（ Windows PC | 安卓 | MAC ）及设置微信不更新