RocketMQ源码(十七)之消费者启动

最新推荐文章于 2024-05-15 17:33:05 发布
原创 最新推荐文章于 2024-05-15 17:33:05 发布 · 1.1k 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#RocketMQ源码 #Consumer启动

文章目录

版本声明

  1. 基于rocketmq-all-4.3.1版本

消费模式

  1. 消费组
    • 一个消费组可以包含多个Consumer，一个消费组可以订阅多个Topic
    • 消费组之间有集群和广播两种消费模式，集群模式下，Topic中的同一条消息只允许被其中一个Consumer消费。广播模式下，Topic中的同一条消息可以被集群中的所有Consumer消费。
  2. 消费模式
    • 拉模式：消息到达Broker后，Consumer主动发起拉取请求
    • 推模式：消息达到Broker后，由Broker推送给Consumer。RocketMQ中推模式的实现是基于拉模式，即一个拉取任务完成后开始下一个拉取任务
  3. 集群模式下，多个Consumer需要对消息队列进行负载均衡。一个消息队列同时只允许被一个Consumer消费，一个Consumer可以消费多个消息队列。

推模式消费

  1. DefaultMQPushConsumer是推模式核心入口类，主要委托DefaultMQPushConsumerImpl实现相关功能。RocketMQ并没有真正实现推模式，而是Consumer主动向消息服务器拉取消息，RocketMQ推模式是循环向Broker端发送消息拉取请求。

  2. DefaultMQPushConsumer核心属性如下

    public class DefaultMQPushConsumer extends ClientConfig implements MQPushConsumer {

  	//委托类，大部分操作都是委托DefaultMQPushConsumerImpl
    protected final transient DefaultMQPushConsumerImpl defaultMQPushConsumerImpl;
		//消费组
    private String consumerGroup;
		// 消息消费模式，分为集群模式、广播模式，默认为集群模式。
    private MessageModel messageModel = MessageModel.CLUSTERING;
  	/**
  	第一次消费时指定消费策略
  	CONSUME_FROM_LAST_OFFSET：此处分为两种情况，如果磁盘消息未过期且未被删除，则从最小偏移量开始消费。如果磁盘已过期并被删除，则从最大偏移量开始消费。
    CONSUME_FROM_FIRST_OFFSET：从队列当前最小偏移量开始消费。
    CONSUME_FROM_TIMESTAMP：从消费者指定时间戳开始消费。
    如果从消息进度服务OffsetStore读取到MessageQueue中的偏移量不小于0，则使用读取到的偏移量拉取消息，只有在读到的偏移量小于0时，上述策略才会生效。
  	**/
    private ConsumeFromWhere consumeFromWhere = ConsumeFromWhere.CONSUME_FROM_LAST_OFFSET;
    private String consumeTimestamp = UtilAll.timeMillisToHumanString3(System.currentTimeMillis() - (1000 * 60 * 30));

  	// 集群模式下消息队列的负载策略
    private AllocateMessageQueueStrategy allocateMessageQueueStrategy;
		// 订阅信息
    private Map<String /* topic */, String /* sub expression */> subscription = new HashMap<String, String>();
		// 消息业务监听器。
    private MessageListener messageListener;
		// 消息消费进度存储器。
    private OffsetStore offsetStore;
		// 费者最小线程数
    private int consumeThreadMin = 20;
		// 消费者最大线程数
    private int consumeThreadMax = 64;
    private long adjustThreadPoolNumsThreshold = 100000;

    //并发消息消费时处理队列最大跨度
    private int consumeConcurrentlyMaxSpan = 2000;
		//每1000次流控后打印流控日志
    private int pullThresholdForQueue = 1000;

    private int pullThresholdSizeForQueue = 100;

    private int pullThresholdForTopic = -1;
		
    private int pullThresholdSizeForTopic = -1;

		// 推模式下拉取任务的间隔时间
    private long pullInterval = 0;

		//消息并发消费时一次消费消息的条数
    private int consumeMessageBatchMaxSize = 1;

   	//每次消息拉取的条数
    private int pullBatchSize = 32;

   	// 是否每次拉取消息都更新订阅信息，默认为false。
    private boolean postSubscriptionWhenPull = false;

    /**
     * Whether the unit of subscription group
     */
    private boolean unitMode = false;

		// 最大消费重试次数
    private int maxReconsumeTimes = -1;

  	// 延迟将该队列的消息提交到消费者线程的等待时间，默认延迟1s
    private long suspendCurrentQueueTimeMillis = 1000;

		// 息消费超时时间
    private long consumeTimeout = 15;

启动流程

  1. DefaultMQPushConsumer启动就是委托DefaultMQPushConsumerImpl来实现的

    @Override
public void start() throws MQClientException {
    this.defaultMQPushConsumerImpl.start();
}

  2. DefaultMQPushConsumerImpl启动流程图

在这里插入图片描述

  1. 启动源码

    public synchronized void start() throws MQClientException {
switch (this.serviceState) {
    case CREATE_JUST:
        log.info("the consumer [{}] start beginning. messageModel={}, isUnitMode={}", this.defaultMQPushConsumer.getConsumerGroup(),
            this.defaultMQPushConsumer.getMessageModel(), this.defaultMQPushConsumer.isUnitMode());
        this.serviceState = ServiceState.START_FAILED;
        //1. 检查配置
        this.checkConfig();
        //2. 构建订阅SubscriptionData信息，并加入到RebalanceImpl的订阅消息中
        this.copySubscription();

        if (this.defaultMQPushConsumer.getMessageModel() == MessageModel.CLUSTERING) {
            this.defaultMQPushConsumer.changeInstanceNameToPID();
        }
        //3. 实例化MQClientInstance
        this.mQClientFactory = MQClientManager.getInstance().getAndCreateMQClientInstance(this.defaultMQPushConsumer, this.rpcHook);
        //4. 设置reblance属性
        this.rebalanceImpl.setConsumerGroup(this.defaultMQPushConsumer.getConsumerGroup());
        this.rebalanceImpl.setMessageModel(this.defaultMQPushConsumer.getMessageModel());
        this.rebalanceImpl.setAllocateMessageQueueStrategy(this.defaultMQPushConsumer.getAllocateMessageQueueStrategy());
        this.rebalanceImpl.setmQClientFactory(this.mQClientFactory);
        //5. 设置pullAPIWrapper的消息过滤Hook
        this.pullAPIWrapper = new PullAPIWrapper(
            mQClientFactory,
            this.defaultMQPushConsumer.getConsumerGroup(), isUnitMode());
        this.pullAPIWrapper.registerFilterMessageHook(filterMessageHookList);
        //6.
        if (this.defaultMQPushConsumer.getOffsetStore() != null) {
            this.offsetStore = this.defaultMQPushConsumer.getOffsetStore();
        } else {
            switch (this.defaultMQPushConsumer.getMessageModel()) {
                case BROADCASTING:
                    //如果是广播模式则消费进度保存在本地
                    this.offsetStore = new LocalFileOffsetStore(this.mQClientFactory, this.defaultMQPushConsumer.getConsumerGroup());
                    break;
                case CLUSTERING:
                    //集群模式消费进度保存在服务端
                    this.offsetStore = new RemoteBrokerOffsetStore(this.mQClientFactory, this.defaultMQPushConsumer.getConsumerGroup());
                    break;
                default:
                    break;
            }
            this.defaultMQPushConsumer.setOffsetStore(this.offsetStore);
        }
        this.offsetStore.load();

        // 顺序消费和并发消费，创建对应的消费线程服务
        if (this.getMessageListenerInner() instanceof MessageListenerOrderly) {
            this.consumeOrderly = true;
            this.consumeMessageService =
                new ConsumeMessageOrderlyService(this, (MessageListenerOrderly) this.getMessageListenerInner());
        } else if (this.getMessageListenerInner() instanceof MessageListenerConcurrently) {
            this.consumeOrderly = false;
            this.consumeMessageService =
                new ConsumeMessageConcurrentlyService(this, (MessageListenerConcurrently) this.getMessageListenerInner());
        }

        this.consumeMessageService.start();
        // 向MQClientInstance注册消费者实例
        boolean registerOK = mQClientFactory.registerConsumer(this.defaultMQPushConsumer.getConsumerGroup(), this);
        if (!registerOK) {
            this.serviceState = ServiceState.CREATE_JUST;
            this.consumeMessageService.shutdown();
            throw new MQClientException("The consumer group[" + this.defaultMQPushConsumer.getConsumerGroup()
                + "] has been created before, specify another name please." + FAQUrl.suggestTodo(FAQUrl.GROUP_NAME_DUPLICATE_URL),
                null);
        }
        // 启动MQClientInstance实例
        mQClientFactory.start();
        log.info("the consumer [{}] start OK.", this.defaultMQPushConsumer.getConsumerGroup());
        this.serviceState = ServiceState.RUNNING;
        break;
    case RUNNING:
    case START_FAILED:
    case SHUTDOWN_ALREADY:
        throw new MQClientException("The PushConsumer service state not OK, maybe started once, "
            + this.serviceState
            + FAQUrl.suggestTodo(FAQUrl.CLIENT_SERVICE_NOT_OK),
            null);
    default:
        break;
}

  2. 检查配置

    private void checkConfig() throws MQClientException {
    /**
     * 1. 消费组名称不能为空
     * 2. 消费组名称必须符合正则表达式**^[%|a-zA-Z0-9_-]+$
     * 3. 消费组名称不能大于255
     */
    Validators.checkGroup(this.defaultMQPushConsumer.getConsumerGroup());
    //为什么又检查一遍？
    if (null == this.defaultMQPushConsumer.getConsumerGroup()) {
        throw new MQClientException(
            "consumerGroup is null"
                + FAQUrl.suggestTodo(FAQUrl.CLIENT_PARAMETER_CHECK_URL),
            null);
    }
    //消费组名称不能等于DEFAULT_CONSUMER
    if (this.defaultMQPushConsumer.getConsumerGroup().equals(MixAll.DEFAULT_CONSUMER_GROUP)) {
        throw new MQClientException(
            "consumerGroup can not equal "
                + MixAll.DEFAULT_CONSUMER_GROUP
                + ", please specify another one."
                + FAQUrl.suggestTodo(FAQUrl.CLIENT_PARAMETER_CHECK_URL),
            null);
    }
    //消费模式不能为空，集群或者广播，默认是集群模式
    if (null == this.defaultMQPushConsumer.getMessageModel()) {
        throw new MQClientException(
            "messageModel is null"
                + FAQUrl.suggestTodo(FAQUrl.CLIENT_PARAMETER_CHECK_URL),
            null);
    }
    //默认从上一个CONSUME_FROM_LAST_OFFSET
    if (null == this.defaultMQPushConsumer.getConsumeFromWhere()) {
        throw new MQClientException(
            "consumeFromWhere is null"
                + FAQUrl.suggestTodo(FAQUrl.CLIENT_PARAMETER_CHECK_URL),
            null);
    }
    //第一次启动，默认从半小时前消费
    Date dt = UtilAll.parseDate(this.defaultMQPushConsumer.getConsumeTimestamp(), UtilAll.YYYYMMDDHHMMSS);
    if (null == dt) {
        throw new MQClientException(
            "consumeTimestamp is invalid, the valid format is yyyyMMddHHmmss,but received "
                + this.defaultMQPushConsumer.getConsumeTimestamp()
                + " " + FAQUrl.suggestTodo(FAQUrl.CLIENT_PARAMETER_CHECK_URL), null);
    }

    // allocateMessageQueueStrategy
    if (null == this.defaultMQPushConsumer.getAllocateMessageQueueStrategy()) {
        throw new MQClientException(
            "allocateMessageQueueStrategy is null"
                + FAQUrl.suggestTodo(FAQUrl.CLIENT_PARAMETER_CHECK_URL),
            null);
    }

    // subscription
    if (null == this.defaultMQPushConsumer.getSubscription()) {
        throw new MQClientException(
            "subscription is null"
                + FAQUrl.suggestTodo(FAQUrl.CLIENT_PARAMETER_CHECK_URL),
            null);
    }

    // messageListener
    if (null == this.defaultMQPushConsumer.getMessageListener()) {
        throw new MQClientException(
            "messageListener is null"
                + FAQUrl.suggestTodo(FAQUrl.CLIENT_PARAMETER_CHECK_URL),
            null);
    }
    //顺序消费监听
    boolean orderly = this.defaultMQPushConsumer.getMessageListener() instanceof MessageListenerOrderly;
    //并发消费监听
    boolean concurrently = this.defaultMQPushConsumer.getMessageListener() instanceof MessageListenerConcurrently;
    if (!orderly && !concurrently) {
        throw new MQClientException(
            "messageListener must be instanceof MessageListenerOrderly or MessageListenerConcurrently"
                + FAQUrl.suggestTodo(FAQUrl.CLIENT_PARAMETER_CHECK_URL),
            null);
    }

    // consumeThreadMin  最小消费线程数量只能在[1,1000]之间，默认20
    if (this.defaultMQPushConsumer.getConsumeThreadMin() < 1
        || this.defaultMQPushConsumer.getConsumeThreadMin() > 1000) {
        throw new MQClientException(
            "consumeThreadMin Out of range [1, 1000]"
                + FAQUrl.suggestTodo(FAQUrl.CLIENT_PARAMETER_CHECK_URL),
            null);
    }

    // consumeThreadMax  最大消费线程数量只能在[1,1000]之间，默认64
    if (this.defaultMQPushConsumer.getConsumeThreadMax() < 1 || this.defaultMQPushConsumer.getConsumeThreadMax() > 1000) {
        throw new MQClientException(
            "consumeThreadMax Out of range [1, 1000]"
                + FAQUrl.suggestTodo(FAQUrl.CLIENT_PARAMETER_CHECK_URL),
            null);
    }

    // consumeThreadMin can't be larger than consumeThreadMax
    if (this.defaultMQPushConsumer.getConsumeThreadMin() > this.defaultMQPushConsumer.getConsumeThreadMax()) {
        throw new MQClientException(
            "consumeThreadMin (" + this.defaultMQPushConsumer.getConsumeThreadMin() + ") "
                + "is larger than consumeThreadMax (" + this.defaultMQPushConsumer.getConsumeThreadMax() + ")",
            null);
    }

    //偏移量最大的消息与偏移量最小的消息跨度设置只能在[1,65535],默认2000
    // consumeConcurrentlyMaxSpan
    if (this.defaultMQPushConsumer.getConsumeConcurrentlyMaxSpan() < 1
        || this.defaultMQPushConsumer.getConsumeConcurrentlyMaxSpan() > 65535) {
        throw new MQClientException(
            "consumeConcurrentlyMaxSpan Out of range [1, 65535]"
                + FAQUrl.suggestTodo(FAQUrl.CLIENT_PARAMETER_CHECK_URL),
            null);
    }

    //队列级别的流控阈值，默认每个消息队列缓存1000条消息，设置范围[1,65535]
    // pullThresholdForQueue
    if (this.defaultMQPushConsumer.getPullThresholdForQueue() < 1 || this.defaultMQPushConsumer.getPullThresholdForQueue() > 65535) {
        throw new MQClientException(
            "pullThresholdForQueue Out of range [1, 65535]"
                + FAQUrl.suggestTodo(FAQUrl.CLIENT_PARAMETER_CHECK_URL),
            null);
    }

    //topic级别的流控，默认-1(无限制)，设置范围[1,6553500],如果设置为有限值，则根据pullThresholdForTopic来计算并覆盖pullThresholdForQueue的配置
    // pullThresholdForTopic
    if (this.defaultMQPushConsumer.getPullThresholdForTopic() != -1) {
        if (this.defaultMQPushConsumer.getPullThresholdForTopic() < 1 || this.defaultMQPushConsumer.getPullThresholdForTopic() > 6553500) {
            throw new MQClientException(
                "pullThresholdForTopic Out of range [1, 6553500]"
                    + FAQUrl.suggestTodo(FAQUrl.CLIENT_PARAMETER_CHECK_URL),
                null);
        }
    }

    //在队列级别限制消息大小，每个队列最多缓存100MB(默认)的消息，设置范围[1,1024].
    // pullThresholdSizeForQueue
    if (this.defaultMQPushConsumer.getPullThresholdSizeForQueue() < 1 || this.defaultMQPushConsumer.getPullThresholdSizeForQueue() > 1024) {
        throw new MQClientException(
            "pullThresholdSizeForQueue Out of range [1, 1024]"
                + FAQUrl.suggestTodo(FAQUrl.CLIENT_PARAMETER_CHECK_URL),
            null);
    }
    //在topic级别限制消息大小,默认-1表示不限制，设置范围[1,102400].
    if (this.defaultMQPushConsumer.getPullThresholdSizeForTopic() != -1) {
        // pullThresholdSizeForTopic
        if (this.defaultMQPushConsumer.getPullThresholdSizeForTopic() < 1 || this.defaultMQPushConsumer.getPullThresholdSizeForTopic() > 102400) {
            throw new MQClientException(
                "pullThresholdSizeForTopic Out of range [1, 102400]"
                    + FAQUrl.suggestTodo(FAQUrl.CLIENT_PARAMETER_CHECK_URL),
                null);
        }
    }

    //推模式下，消息拉取的时间间隔，默认0，配置范围[0,65535]
    // pullInterval
    if (this.defaultMQPushConsumer.getPullInterval() < 0 || this.defaultMQPushConsumer.getPullInterval() > 65535) {
        throw new MQClientException(
            "pullInterval Out of range [0, 65535]"
                + FAQUrl.suggestTodo(FAQUrl.CLIENT_PARAMETER_CHECK_URL),
            null);
    }

    //消息并发消费时，一次消费的消息条数，默认值为1，配置返回[1,1024]
    // consumeMessageBatchMaxSize
    if (this.defaultMQPushConsumer.getConsumeMessageBatchMaxSize() < 1
        || this.defaultMQPushConsumer.getConsumeMessageBatchMaxSize() > 1024) {
        throw new MQClientException(
            "consumeMessageBatchMaxSize Out of range [1, 1024]"
                + FAQUrl.suggestTodo(FAQUrl.CLIENT_PARAMETER_CHECK_URL),
            null);
    }

    //每次消息拉取所拉取的条数，默认32，配置范围[1,1024]
    // pullBatchSize
    if (this.defaultMQPushConsumer.getPullBatchSize() < 1 || this.defaultMQPushConsumer.getPullBatchSize() > 1024) {
        throw new MQClientException(
            "pullBatchSize Out of range [1, 1024]"
                + FAQUrl.suggestTodo(FAQUrl.CLIENT_PARAMETER_CHECK_URL),
            null);
    }
}

拉模式消费

  1. DefaultMQPullConsumer是拉模式核心入口类，主要委托DefaultMQPullConsumerImpl实现相关功能。拉模式启动通过MQPullConsumerScheduleService来进行调度
  2. DefaultMQPushConsumer是推模式核心入口类，主要委托DefaultMQPushConsumerImpl实现相关功能。RocketMQ并没有真正实现推模式，而是Consumer主动向消息服务器拉取消息，RocketMQ推模式是循环向Broker端发送消息拉取请求。

启动流程

  1. DefaultMQPullConsumer委托DefaultMQPullConsumerImpl启动

    @Override
public void start() throws MQClientException {
    this.defaultMQPullConsumerImpl.start();
}

  2. DefaultMQPullConsumerImpl启动流程与DefaultMQPushConsumerImpl几乎一样,不再赘述

配置参数总结

  1. 消费组名称规则

    • 消费组(consumerGroup)名称不能为空

    • 消费组(consumerGroup)名称必须符合正则表达式**1+$**

    • 消费组(consumerGroup)名称不能大于255

    • 消费组名称不能等于DEFAULT_CONSUMER

  2. 消费模式

    • 集群模式（默认）
    • 广播模式

  3. consumeFromWhere:如果从消费进度OffsetStore读取到的MessageQueue中的偏移量小于0时，采取以下的配置策略。

    • CONSUME_FROM_LAST_OFFSET:从队列当前最大偏移量开始消费(默认配置)
    • CONSUME_FROM_FIRST_OFFSET:从队列当前最小偏移量开始消费
    • CONSUME_FROM_TIMESTAMP:从Consumer启动时间戳开始消费

  4. 消费线程

    • 最小消费线程数量只能在[1,1000]之间，默认20
    • 最大消费线程数量只能在[1,1000]之间，默认64

  5. 偏移量：偏移量最大的消息与偏移量最小的消息跨度设置只能在[1,65535],默认2000

  6. 队列级别的流控阈值，默认每个消息队列缓存1000条消息，设置范围[1,65535]

  7. topic级别的流控，默认-1(无限制)，设置范围[1,6553500],如果设置为有限值，则根据pullThresholdForTopic来计算并覆盖pullThresholdForQueue的配置

  8. 在队列级别限制消息大小，每个队列最多缓存100MB(默认)的消息，设置范围[1,1024].

  9. 在topic级别限制消息大小,默认-1表示不限制，设置范围[1,102400].

  10. 推模式下，消息拉取的时间间隔，默认0，配置范围[0,65535]

  11. 消息并发消费时，一次消费的消息条数，默认值为1，配置返回[1,1024]

  12. 每次消息拉取所拉取的条数，默认32，配置范围[1,1024]

  1. %|a-zA-Z0-9_- ↩︎

我的架构梦：（九十七）消息中间件之RocketMQ的高可用机制——消息存储高可用
riemann_的博客
03-13 645
一、前言 作为一款消息中间件产品，高可用起着至关重要的作用。那 RocketMQ 是怎么保证高可用机制的呢？老周从四个维度来分析：消息存储高可用、消息发送高可用、消息消费高可用以及消息管理高可用。本文主要侧重讲消息存储高可用，其它三个维度老周也会说一下。话不多说，我们现在就开始 RocketMQ 的高可用机制之旅吧。 二、消息存储高可用 很多需要持久化的产品，它们的高可用机制一般都是主从复制和读写分离。RocketMQ 消息存储的高可用也不例外。既然这样，那我们就从这两个方向来分析一下。 1、主从复制 2、
面试题：一个consumer订阅两个topic，其中一个topic消息过多堆积了，会影响另一个topic消费吗
乐乐的博客
07-15 2804
问题：一个consumer订阅两个topic，其中一个topic消息过多堆积了，会影响另一个topic消费吗 答案：不影响。 为什么呢？ 因为rocketmq首先对消息进行负载均衡（rebalance），就是将topic中的队列按照consumer进行分配之后，将pullRequest(里面存放了topic,brokerName,queueId)放入到一个linkedBlockingQueue中，这个时候已经排好了后面消费的顺序。例如100个request中有大概50个是TopicTest1, 另外50个是
RocketMQ-核心篇(2)-核心概念
TianXinCoord的博客
05-15 9960
文章目录一、消息模型（Message Model）二、消息生产者（Producer）三、消息消费者（Consumer）四、主题（Topic）五、代理服务器（Broker Server）六、名字服务（Name Server）七、拉取式消费（Pull Consumer）八、推动式消费（Push Consumer）九、生产者组（Producer Group）十、消费者组（Consumer Group）十一、集群消费（Clustering）十二、广播消费（Broadcasting）十三、普通顺序消息（Normal
RocketMQ同一topic，多个消费组
hgg923的专栏
08-28 1万+
多个消费组可以同时消费同一个topic的消息，每个消费组内部的消费者可以独立地消费消息。这种设计方式可以实现消息的并行消费和负载均衡，确保每个消费组都可以按照自己的速度独立地消费消息。消息负载均衡：RocketMQ会根据消费组的订阅关系和消费进度，动态地将消息分发给消费组中的消费者实例。消费组：当一个新的消费组启动时，它需要向Broker注册，并创建一个唯一的Group ID。消息分发：当消息发送到Broker后，Broker会根据消费组的订阅关系，将消息推送给所有订阅了该topic的消费组。
RocketMQ中单消费者订阅多个Topic，会阻塞消费吗？
u011385940的专栏
05-05 6500
5.0之前的客户端架构中，拉取到消息之后会先将消息缓存到 ProcessQueue 中，当需要消费时，会从 ProcessQueue 中取出对应的消息进行消费，当消费成功之后再将消息从 ProcessQueue 中 remove 走。
springboot整合rocketmq：一个消费者组怎么订阅多个topic
weixin_38456989的博客
11-19 1万+
一个消费组（消费者）订阅多个topic的代码
消息中间件之RocketMQ源码分析(十七)
Cover_sky的博客
02-26 536
主要用于消费拉取消息、更新消费位点等所用的索引。源代码参考org.apache.rocketmq.store.ConsumerQueue.该文件内保存了消息的物理位点、消息体大小、消息Tag的Hash值。
第十七章-消费者-PULL方式
zhang527294844的博客
05-15 635
消费者-PULL方式
三、RocketMQ_18(笔记)
姷礼的博客
08-23 556
RocketMQ消息中间件
rocketmq (消费者消费同一个消费组，不同的topic)
chengchong_cc的博客
03-19 1797
【代码】rocketmq (消费者消费同一个消费组，不同的topic)
RocketMQ同一个消费者内消费者订阅不同Topic问题分析
Mamba Out
06-28 1万+
背景 在一个服务里起了两个消费者，并且这两个消费者属于同一个组，但是这两个消费者所订阅的Topic是不相同的，出现了只有一个消费者在消费消息，另外一个不消费消息 分析 经过走查broker端代码发现如下代码： 重点在步骤4和5.1和5.2，现在只针对一个broker做一下分析： 假设consumer1先启动，对于broker_a一开始关系是group1->topic1 当consumer2启动并rebalance完成后，consumer2发送group1->topic2, 在步
Rocketmq中同一个消费者订阅两个topic
qq_44993268的博客
05-24 3575
在聊天项目中，需要将消息异步保存到同步到数据库和ES文档中，而ES的mapping中包含了私聊和群聊两种消息模块。现在需要ES的消费组同时订阅私聊和群聊的topic，并都转为ES的消息文档格式并保存。
RocketMq消费者组下多个消费者订阅关系不一致
weixin_44857939的博客
07-26 1658
原因在于再给消费者组下面的多个消费者分配消息队列时。并没有细分到topic维度。直接根据消费者组下有几个消费者进行分配。不管有没有监听这个topic。都会给他分配这个topic的消息队列queue。但是他却没有消费，就会造成消息堆积。1、RocketMq规定同一个消费者组下的消费者订阅关系（订阅了哪些Topic。tag是什么）一定要一致。而且和生产者组的topic tag一致。topic可以使用tag进行过滤。生产者可以发送带tag的消息。消费者如果tag不一致，会把消息过滤掉。tag不一致造成消息丢失。
Topic太多！RocketMQ炸了！
xxxzzzqqq_的博客
04-12 1901
网上博客常说，kafka的topic数量过多会影响kafka，而RocketMQ不会受到topic数量影响。但是，果真如此吗？最近排查一个问题，发现RocketMQ稳定性同样受到topic数量影响！！好了，一起来回顾下这次问题排查吧，和放在最后，千万不要错过。
rocketMq被多实例重复消费问题
sillyyyy的博客
05-08 3656
要防止 RocketMQ 被多实例重复消费，您可以使用 RocketMQ 提供的消息消费者集群特性，来确保每条消息只被一个消费者实例消费一次。在 RocketMQ 中，一个消费者集群由多个消费者实例组成，每个消费者实例在启动时会指定一个唯一的消费者组名（Consumer Group Name），消费者组名相同的消费者实例会共同消费订阅的消息主题（Topic）。3. 当有新的消息到达时，RocketMQ 会将消息均衡地分配到消费者集群中的所有消费者实例中，确保每条消息只被一个消费者实例消费一次。
RocketMQ的Topic配置多消费方
仰望的博客
08-24 5844
同事压测过程中反馈MQ成为瓶颈，通过MQ控制台发现topic消费方只有一个，而这个RocketMQ是3台机器集群，故需要增加RocketMQ的consumer来缓解压力。broker_name是选择消费方数量，再写上topic名称，其他配置项和原来配置保持一样即可。3、点击对应topic的topic config，查看消费方有几个。4、若需要修改或新增topic的消费方，点击Add/Update。2、输入topic名称查询对应topic。1、登录到MQ控制台，点topic。
RocketMQ
奋斗的青年
03-17 7196
1.主题中存在多个队列，生产者向主题中指定的队列发送消息 2.在集群模式下，一个消费者集群共同消费一个主题中的多个队列，但一个队列只会被一个消费者消费;在广播模式下，会被订阅主题的所有消费者消费 3.每个消费者组在每个队列上维护一个消费位移(offset)，消费者每消费一条消息，会发送一个成功响应，位移就向前移动一次，避免消息重复消费 4.RocketMQ通过一个主题配置多个队列，每个队列维护消费者组的消费位移实现主题模式，提高并发能力 5.一个topic分布多个broker上，一个broker上有
Kafka：Consumer订阅
kaven
02-14 3612
测试代码 pom.xml： <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apac
Rocketmq一个生产者多个消费者的问题
远方的少年
11-30 1万+
消费者同组时，有两种消息模式。 1.集群模式，多个消费者通过负载均衡一起消费信息 2.广播模式，一个消息会复制成多份分发给每一个消费者 消费者不同组时 一个消息会复制多份发给不同的消费者组 public class SyncProducer { public static void main(String[] args) throws Exception{ ...
rocketmq问题汇总-一个consumerGroup只对应一个topic
热门推荐
MQCloud的专栏
02-14 9万+
1 同一个订阅组内不同Consumer实例订阅不同topic消费混乱问题调查 图1： 背景说明： 如图1左半部分，假设目前的关系如下： broker： 两个，broker_a和broker_b topic：两个，topic1和topic2，每个topic在每个broker上分为4个queue consumer：两个，consumer1和consumer2
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值