14. Consumer-负载均衡

最新推荐文章于 2025-05-29 18:15:00 发布

原创最新推荐文章于 2025-05-29 18:15:00 发布 · 414 阅读

0 ·

CC 4.0 BY-SA版权

rocketmq源码学习专栏收录该内容

14 篇文章

订阅专栏

本文详细解析了集群模式下，消息队列如何通过负载均衡策略确保多个消费者公平地分配主题下的队列资源。阐述了RebalanceService线程如何每20秒进行一次负载均衡，以及RebalanceImpl类中rebalanceByTopic方法如何根据不同消息模型（广播或集群）进行队列分配。特别关注了在集群模式下，如何通过分配策略平均分配队列，并在分配结果变化时更新流控阈值。

集群模式下，同一个消费组下，多个消费者同时订阅同一个主题，但是主题下的每个队列同时只能被一个消费端消费，所以需要进行负载均衡，确定哪些队列由哪些消费者消费。

如果消费者数量大于队列数，可能有的消费者没有分配到队列；相反，如果如果消费者数量小于队列数，一个消费者可能会被分配到多个队列。

负载均衡是由RebalanceService线程实现的。

RebalanceService.run方法：

    public void run() {
        log.info(this.getServiceName() + " service started");

        while (!this.isStopped()) {
            //waitInterval=20000
            this.waitForRunning(waitInterval);
            this.mqClientFactory.doRebalance();
        }

        log.info(this.getServiceName() + " service end");
    }

每20s进行一次负载均衡，具体实现类位于

RebalanceImpl.doRebalance方法中

    //isOrder：是否顺序消费    
    public void doRebalance(final boolean isOrder) {
        Map<String, SubscriptionData> subTable = this.getSubscriptionInner();
        if (subTable != null) {
            for (final Map.Entry<String, SubscriptionData> entry : subTable.entrySet()) {
                final String topic = entry.getKey();
                try {
                    this.rebalanceByTopic(topic, isOrder);
                } catch (Throwable e) {
                    if (!topic.startsWith(MixAll.RETRY_GROUP_TOPIC_PREFIX)) {
                        log.warn("rebalanceByTopic Exception", e);
                    }
                }
            }
        }

        this.truncateMessageQueueNotMyTopic();
    }

遍历所有主题，根据主题进行重新负载均衡

RebalanceImpl.rebalanceByTopic方法：

    private void rebalanceByTopic(final String topic, final boolean isOrder) {
        switch (messageModel) {
            case BROADCASTING: {
                //广播模式没有负载均衡，只比较当前主题的队列和上次分配的是否一致。
                Set<MessageQueue> mqSet = this.topicSubscribeInfoTable.get(topic);
                if (mqSet != null) {
                    boolean changed = this.updateProcessQueueTableInRebalance(topic, mqSet, isOrder);
                    if (changed) {
                        this.messageQueueChanged(topic, mqSet, mqSet);
                        log.info("messageQueueChanged {} {} {} {}",
                            consumerGroup,
                            topic,
                            mqSet,
                            mqSet);
                    }
                } else {
                    log.warn("doRebalance, {}, but the topic[{}] not exist.", consumerGroup, topic);
                }
                break;
            }
            case CLUSTERING: {
                Set<MessageQueue> mqSet = this.topicSubscribeInfoTable.get(topic);
                List<String> cidAll = this.mQClientFactory.findConsumerIdList(topic, consumerGroup);
                if (null == mqSet) {
                    if (!topic.startsWith(MixAll.RETRY_GROUP_TOPIC_PREFIX)) {
                        log.warn("doRebalance, {}, but the topic[{}] not exist.", consumerGroup, topic);
                    }
                }

                if (null == cidAll) {
                    log.warn("doRebalance, {} {}, get consumer id list failed", consumerGroup, topic);
                }

                if (mqSet != null && cidAll != null) {
                    List<MessageQueue> mqAll = new ArrayList<MessageQueue>();
                    mqAll.addAll(mqSet);

                    Collections.sort(mqAll);
                    Collections.sort(cidAll);

                    //负载均衡策略，默认是平均分配
                    AllocateMessageQueueStrategy strategy = this.allocateMessageQueueStrategy;

                    List<MessageQueue> allocateResult = null;
                    try {
                        //获取分配结果
                        allocateResult = strategy.allocate(
                            this.consumerGroup,
                            this.mQClientFactory.getClientId(),
                            mqAll,
                            cidAll);
                    } catch (Throwable e) {
                        log.error("AllocateMessageQueueStrategy.allocate Exception. allocateMessageQueueStrategyName={}", strategy.getName(),
                            e);
                        return;
                    }

                    Set<MessageQueue> allocateResultSet = new HashSet<MessageQueue>();
                    if (allocateResult != null) {
                        allocateResultSet.addAll(allocateResult);
                    }
                    //将新分配到的队列和之前的队列进行比较，判断是否有变化，
                    移除多余的队列，新分配到的队列会生成拉取任务。
传进来的isOrder参数用于判断顺序消费模式下，分配到的新的队列需要向broker发送请求将队列锁定。
                    boolean changed = this.updateProcessQueueTableInRebalance(topic, allocateResultSet, isOrder);
                    if (changed) {
                        //发生了变化，更新一些流控阈值，重新发送心跳到broker                    
                        this.messageQueueChanged(topic, mqSet, allocateResultSet);
                    }
                }
                break;
            }
            default:
                break;
        }
    }