18. consumer与broker如何处理消费进度？

最新推荐文章于 2024-06-05 15:45:50 发布
最新推荐文章于 2024-06-05 15:45:50 发布
阅读量499 收藏
点赞数
分类专栏： rocketmq 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZXH240651200/article/details/121685511
版权

接上篇文章：17. consuemr如何处理拉取到的消息？_ZXH240651200的博客-CSDN博客
看看ConsumeRequest在调用listener.consumeMessage()之后的处理

ConsumeMessageConcurrentlyService.ConsumeRequest.run()

public void run() {
            ...
            //处理消费结果
            if (!processQueue.isDropped()) {
                ConsumeMessageConcurrentlyService.this.processConsumeResult(status, context, this);
            } else {
                log.warn("processQueue is dropped without process consume result. messageQueue={}, msgs={}", messageQueue, msgs);
            }
        }

调用了processConsumeRequest()去处理消费结果

    public void processConsumeResult(
        final ConsumeConcurrentlyStatus status,
        final ConsumeConcurrentlyContext context,
        final ConsumeRequest consumeRequest
    ) {
        // 设置ackIndex，这个值在创建ConsumeConcurrentlyContext时默认为Integer.MAX_VALUE
        int ackIndex = context.getAckIndex();

        if (consumeRequest.getMsgs().isEmpty())
            return;

        switch (status) {
            // 消费成功
            case CONSUME_SUCCESS:
                // 设置ackIndex=消息数-1，默认情况下=0
                if (ackIndex >= consumeRequest.getMsgs().size()) {
                    ackIndex = consumeRequest.getMsgs().size() - 1;
                }
                // 记录消费成功与消费失败的tps
                int ok = ackIndex + 1;
                int failed = consumeRequest.getMsgs().size() - ok;
                this.getConsumerStatsManager().incConsumeOKTPS(consumerGroup, consumeRequest.getMessageQueue().getTopic(), ok);
                this.getConsumerStatsManager().incConsumeFailedTPS(consumerGroup, consumeRequest.getMessageQueue().getTopic(), failed);
                break;
            case RECONSUME_LATER:
                // 需要再次消费的，设置ackIndex=-1,用于下面的重试
                ackIndex = -1;
                // 记录消费失败tps
                this.getConsumerStatsManager().incConsumeFailedTPS(consumerGroup, consumeRequest.getMessageQueue().getTopic(),
                    consumeRequest.getMsgs().size());
                break;
            default:
                break;
        }

        switch (this.defaultMQPushConsumer.getMessageModel()) {
            case BROADCASTING:
                ...
                break;
            case CLUSTERING:
                List<MessageExt> msgBackFailed = new ArrayList<MessageExt>(consumeRequest.getMsgs().size());
                // 将消费失败的消息，重新发送到broker，
                for (int i = ackIndex + 1; i < consumeRequest.getMsgs().size(); i++) {
                    MessageExt msg = consumeRequest.getMsgs().get(i);
                    // 将消息重新发送到broker
                    boolean result = this.sendMessageBack(msg, context);
                    if (!result) {
                        msg.setReconsumeTimes(msg.getReconsumeTimes() + 1);
                        msgBackFailed.add(msg);
                    }
                }
                // 发送到brker失败
                if (!msgBackFailed.isEmpty()) {
                    consumeRequest.getMsgs().removeAll(msgBackFailed);
                    // 会将这些消息包装起来，5s后，再次流转消费
                    this.submitConsumeRequestLater(msgBackFailed, consumeRequest.getProcessQueue(), consumeRequest.getMessageQueue());
                }
                break;
            default:
                break;
        }
        // 从processQueue中删除这小批msg
        // 如果删除这批 消息之后，processQueue为空了 ，说明拉取的这批消息都消费完了，就将offset=最大的消息offset+1
        // 如果processQueue不为空，说明这批拉取的消息还没有消费完，offset=第一个消息的offset
        long offset = consumeRequest.getProcessQueue().removeMessage(consumeRequest.getMsgs());
        //
        if (offset >= 0 && !consumeRequest.getProcessQueue().isDropped()) {
            // 更新本地的消息进度，随后又定时任务同步到broker上
            this.defaultMQPushConsumerImpl.getOffsetStore().updateOffset(consumeRequest.getMessageQueue(), offset, true);
        }
    }

最后调用offsetStrore.updateOffset()更新了本地的offset缓存

  public void updateOffset(MessageQueue mq, long offset, boolean increaseOnly) {
        if (mq != null) {
            AtomicLong offsetOld = this.offsetTable.get(mq);
            if (null == offsetOld) {
                offsetOld = this.offsetTable.putIfAbsent(mq, new AtomicLong(offset));
            }

            if (null != offsetOld) {
                if (increaseOnly) {
                    MixAll.compareAndIncreaseOnly(offsetOld, offset);
                } else {
                    offsetOld.set(offset);
                }
            }
        }
    }

这里只是将offset保存在本地缓存中，回过头来，有一个定时任务，将本地的offset定时提交到broker,默认5s提交一次

consumer.start() --> defaultMQPushConsumerImpl.start() --> mQClientFactory.start() --> startScheduledTask() 

// 定时任务，持久化消费进度
        this.scheduledExecutorService.scheduleAtFixedRate(new Runnable() {

            @Override
            public void run() {
                try {
                    MQClientInstance.this.persistAllConsumerOffset();
                } catch (Exception e) {
                    log.error("ScheduledTask persistAllConsumerOffset exception", e);
                }
            }
        }, 1000 * 10, this.clientConfig.getPersistConsumerOffsetInterval(), TimeUnit.MILLISECONDS);

--

 private void persistAllConsumerOffset() {
        // 消费列表
        // topic -->  consumer
        Iterator<Entry<String, MQConsumerInner>> it = this.consumerTable.entrySet().iterator();
        while (it.hasNext()) {
            Entry<String, MQConsumerInner> entry = it.next();
            MQConsumerInner impl = entry.getValue();
            impl.persistConsumerOffset();
        }
    }

--

DefaultMQPushConsumerImpl.persisconsumerOffset()

  public void persistConsumerOffset() {
        try {
            this.makeSureStateOK();
            Set<MessageQueue> mqs = new HashSet<MessageQueue>();
            // 获取申请到的messageQueue
            Set<MessageQueue> allocateMq = this.rebalanceImpl.getProcessQueueTable().keySet();
            mqs.addAll(allocateMq);

            this.offsetStore.persistAll(mqs);
        } catch (Exception e) {
            log.error("group: " + this.defaultMQPushConsumer.getConsumerGroup() + " persistConsumerOffset exception", e);
        }
    }

--

org.apache.rocketmq.client.consumer.store.RemoteBrokerOffsetStore#persistAll

public void persistAll(Set<MessageQueue> mqs) {
        if (null == mqs || mqs.isEmpty())
            return;

        final HashSet<MessageQueue> unusedMQ = new HashSet<MessageQueue>();

        for (Map.Entry<MessageQueue, AtomicLong> entry : this.offsetTable.entrySet()) {
            MessageQueue mq = entry.getKey();
            AtomicLong offset = entry.getValue();
            if (offset != null) {
                if (mqs.contains(mq)) {
                    // 有消费进度的messageQueue
                    try {
                        this.updateConsumeOffsetToBroker(mq, offset.get());
                        log.info("[persistAll] Group: {} ClientId: {} updateConsumeOffsetToBroker {} {}",
                            this.groupName,
                            this.mQClientFactory.getClientId(),
                            mq,
                            offset.get());
                    } catch (Exception e) {
                        log.error("updateConsumeOffsetToBroker exception, " + mq.toString(), e);
                    }
                } else {
                    // 没有消费进度的messageQueue
                    unusedMQ.add(mq);
                }
            }
        }

        if (!unusedMQ.isEmpty()) {
            // 删除未消费的messageQueue
            for (MessageQueue mq : unusedMQ) {
                this.offsetTable.remove(mq);
                log.info("remove unused mq, {}, {}", mq, this.groupName);
            }
        }
    }

将有消费进度的messageQueue的offset，发送到broker， 对于没有消费进度messageQueue，重本地的消费队列列表中删除

  private void updateConsumeOffsetToBroker(MessageQueue mq, long offset) throws RemotingException,
        MQBrokerException, InterruptedException, MQClientException {
        // 以单向的方式更新消费进度
        updateConsumeOffsetToBroker(mq, offset, true);
    }

--

    public void updateConsumeOffsetToBroker(MessageQueue mq, long offset, boolean isOneway) throws RemotingException,
        MQBrokerException, InterruptedException, MQClientException {
        FindBrokerResult findBrokerResult = this.mQClientFactory.findBrokerAddressInAdmin(mq.getBrokerName());
        if (null == findBrokerResult) {
            this.mQClientFactory.updateTopicRouteInfoFromNameServer(mq.getTopic());
            findBrokerResult = this.mQClientFactory.findBrokerAddressInAdmin(mq.getBrokerName());
        }

        if (findBrokerResult != null) {
            UpdateConsumerOffsetRequestHeader requestHeader = new UpdateConsumerOffsetRequestHeader();
            requestHeader.setTopic(mq.getTopic());
            requestHeader.setConsumerGroup(this.groupName);
            requestHeader.setQueueId(mq.getQueueId());
            requestHeader.setCommitOffset(offset);

            if (isOneway) {
                // 单向
                // 发送到broker
                this.mQClientFactory.getMQClientAPIImpl().updateConsumerOffsetOneway(
                    findBrokerResult.getBrokerAddr(), requestHeader, 1000 * 5);
            } else {
                this.mQClientFactory.getMQClientAPIImpl().updateConsumerOffset(
                    findBrokerResult.getBrokerAddr(), requestHeader, 1000 * 5);
            }
        } else {
            throw new MQClientException("The broker[" + mq.getBrokerName() + "] not exist", null);
        }
    }

--

public void updateConsumerOffsetOneway(
        final String addr,
        final UpdateConsumerOffsetRequestHeader requestHeader,
        final long timeoutMillis
    ) throws RemotingConnectException, RemotingTooMuchRequestException, RemotingTimeoutException, RemotingSendRequestException,
        InterruptedException {
        RemotingCommand request = RemotingCommand.createRequestCommand(RequestCode.UPDATE_CONSUMER_OFFSET, requestHeader);

        this.remotingClient.invokeOneway(MixAll.brokerVIPChannel(this.clientConfig.isVipChannelEnabled(), addr), request, timeoutMillis);
    }

--

最后封装一个RequestCode.UPDATE_CONSUMER_OFFSET消息，发送到broker

----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

来看看broker是如何处理consumer的更新消费进度的请求的

BrokerController.registerProcessor()

public void registerProcessor() {
        ...

        /**
         * ConsumerManageProcessor
         */
        ConsumerManageProcessor consumerManageProcessor = new ConsumerManageProcessor(this);
        this.remotingServer.registerProcessor(RequestCode.GET_CONSUMER_LIST_BY_GROUP, consumerManageProcessor, this.consumerManageExecutor);
        this.remotingServer.registerProcessor(RequestCode.UPDATE_CONSUMER_OFFSET, consumerManageProcessor, this.consumerManageExecutor);
        this.remotingServer.registerProcessor(RequestCode.QUERY_CONSUMER_OFFSET, consumerManageProcessor, this.consumerManageExecutor);

        this.fastRemotingServer.registerProcessor(RequestCode.GET_CONSUMER_LIST_BY_GROUP, consumerManageProcessor, this.consumerManageExecutor);
        this.fastRemotingServer.registerProcessor(RequestCode.UPDATE_CONSUMER_OFFSET, consumerManageProcessor, this.consumerManageExecutor);
        this.fastRemotingServer.registerProcessor(RequestCode.QUERY_CONSUMER_OFFSET, consumerManageProcessor, this.consumerManageExecutor);
        ...
    }

可以得到RequestCode.UPDATE_CONSUMER_OFFSET消息，是有ConsumerManagerProcessor来处理的

    public RemotingCommand processRequest(ChannelHandlerContext ctx, RemotingCommand request)
        throws RemotingCommandException {
        switch (request.getCode()) {
            case RequestCode.GET_CONSUMER_LIST_BY_GROUP:
                return this.getConsumerListByGroup(ctx, request);
            case RequestCode.UPDATE_CONSUMER_OFFSET:
                // 更新消费者的消费进度
                return this.updateConsumerOffset(ctx, request);
            case RequestCode.QUERY_CONSUMER_OFFSET:
                return this.queryConsumerOffset(ctx, request);
            default:
                break;
        }
        return null;
    }

--

private RemotingCommand updateConsumerOffset(ChannelHandlerContext ctx, RemotingCommand request)
        throws RemotingCommandException {
        final RemotingCommand response =
            RemotingCommand.createResponseCommand(UpdateConsumerOffsetResponseHeader.class);
        final UpdateConsumerOffsetRequestHeader requestHeader =
            (UpdateConsumerOffsetRequestHeader) request
                .decodeCommandCustomHeader(UpdateConsumerOffsetRequestHeader.class);
        // 更新消费者的消费进度
        this.brokerController.getConsumerOffsetManager().commitOffset(RemotingHelper.parseChannelRemoteAddr(ctx.channel()), requestHeader.getConsumerGroup(),
            requestHeader.getTopic(), requestHeader.getQueueId(), requestHeader.getCommitOffset());
        response.setCode(ResponseCode.SUCCESS);
        response.setRemark(null);
        return response;
    }

--

    public void commitOffset(final String clientHost, final String group, final String topic, final int queueId,
        final long offset) {
        // topic@group
        String key = topic + TOPIC_GROUP_SEPARATOR + group;
        this.commitOffset(clientHost, key, queueId, offset);
    }

    private void commitOffset(final String clientHost, final String key, final int queueId, final long offset) {
        ConcurrentMap<Integer, Long> map = this.offsetTable.get(key);
        if (null == map) {
            map = new ConcurrentHashMap<Integer, Long>(32);
            map.put(queueId, offset);
            this.offsetTable.put(key, map);
        } else {
            Long storeOffset = map.put(queueId, offset);
            if (storeOffset != null && offset < storeOffset) {
                log.warn("[NOTIFYME]update consumer offset less than store. clientHost={}, key={}, queueId={}, requestOffset={}, storeOffset={}", clientHost, key, queueId, offset, storeOffset);
            }
        }
    }

可以看到，消费进度保存到offsetTable中了，并没有持久化到磁盘上，

接下来分析offset持久化定时任务

BrokerStartup.main() -->  createBrokerController() --> controller.initialize() --> 
//消费者消费进度持久化定时任务，默认5s持久化一次
            this.scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
                @Override
                public void run() {
                    try {
                        BrokerController.this.consumerOffsetManager.persist();
                    } catch (Throwable e) {
                        log.error("schedule persist consumerOffset error.", e);
                    }
                }
            }, 1000 * 10, this.brokerConfig.getFlushConsumerOffsetInterval(), TimeUnit.MILLISECONDS);

--

public synchronized void persist() {
        String jsonString = this.encode(true);
        if (jsonString != null) {
            String fileName = this.configFilePath();
            try {
                MixAll.string2File(jsonString, fileName);
            } catch (IOException e) {
                log.error("persist file " + fileName + " exception", e);
            }
        }
    }

--

org.apache.rocketmq.broker.offset.ConsumerOffsetManager#configFilePath

public String configFilePath() {
        return BrokerPathConfigHelper.getConsumerOffsetPath(this.brokerController.getMessageStoreConfig().getStorePathRootDir());
    }

--


    public static String getConsumerOffsetPath(final String rootDir) {
        return rootDir + File.separator + "config" + File.separator + "consumerOffset.json";
    }

存储路径为：rootDir/config/consumerOffset.json

 这样就完成了消费者进度的保存

小味
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
探究 | RocketMQ offset管理机制~
m0_71777195的博客
08-29 992
一个Topic会存在多个messageQueue，每个messageQueue都会被Consumer消费，那么Consumer该从哪开始消费呢？这就涉及到offset了，每个messageQueue会记录一个offset表示当前的消费进度，Consumer直接从offset开始消费即可。借用一下网上的图~通过本文，我们了解了RocketMQ的offSet管理机制。
Consumer上报消费位点分析
程序员小潘
10-10 536
1. 前言 在消息中间件中，消费者对于消费成功的消息，一般是需要返回ACK给Broker的，它的目的是让Broker知道消息已经被成功消费，不必再投递给其它消费者重试了。在RocketMQ中，这一过程的具体实现为「上报消费位点」，RocketMQ没有办法针对单个消息返回ACK，Consumer只能上报MessageQueue已经消费的消息偏移量。 ​ Consumer实例启动时，同一Group下所有的实例都会进行「重平衡」操作，给自身重新分配MessageQueue，默认的分配策略就是「平均分配」，这意味着
Go微服务: 基于rocketmq:server和rocketmq:broker搭建RocketMQ环境，以及生产消息和延迟消费消息的实现
最新发布
Wang的专栏
06-05 700
以上是简单的环境搭建和生产消息，以及延迟消费消息的 demo 示例实际场景中，结合以上demo，对一些异步发送消息的场景进行灵活运用和升级。
RocketMQ源码分析之拉取消息（3）
05-02 899
心跳发送完毕后获取broker对应的版本，组装更新消费偏移量请求头UpdateConsumerOffsetRequestHeader，请求码是UPDATE_CONSUMER_OFFSET = 15 public void updateConsumerOffsetOneway( final String addr, final UpdateConsumerOffsetReque...
RocketMQ之消费者并发消费源码解析
我神级欧文的博客
12-23 3828
一.并发消费使用示例： public class BalanceComuser { public static void main(String[] args) throws Exception { // 实例化消息生产者,指定组名 DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("consumerGroup"); // 指定Namesrv地址信息. consum
RocketMQ源码(25)—DefaultMQPushConsumer消费进度管理源码
终生学习践行者
04-07 1145
RocketMQ DefaultMQPushConsumer消费进度管理源码
RocketMQ重复消费问题排查历程
small_bao的博客
02-01 1617
版本：4.2.0，源码：class文件 问题描述： 生产环境日志目录使用的默认配置，MQ启动用户的家目录可用空间设置的大小有限制，随着时间的推移可用空间不足，决定修改日志目录，MQ的logback_*.xml配置的默认路径${user.home}全局替换为/data，然后重启MQ，生产环境使用的双master，分别是19和20服务器，运维在重启的时候先停止的19号服务器的MQ一分二十秒之后启动MQ，五分钟之后停止20号服务器MQ，再启动20号服务器MQ。 启动使用的命令： nohup sh mqna
Rocketmq 消息消费监控
八荒六合唯我独尊
11-09 1337
比较通用的消息监控方式： 累加consumer负载的consumer queue的消息延迟量，消息延迟量= brokerOffset-consumerOffset. 这个统计并不严谨： 1. consumer queue中存储的消息是全量消息，而consumer客户端订阅的往往是过滤消息 （ by tag） 2. consumerOffset并非实时更新，可能异步更新，也可能是下次拉取消息的时候更新的，也可能因为此条消息消费卡顿导致一直无法正常更新进度，因此存在一定的更新延迟。 推荐的监控方式：
rocketmq的消费者源码解读二（消费负载均衡）
主攻中间件方向，喜欢研究相关源码，欢迎一起讨论，共同进步
04-03 590
消费者之负载均衡
【Bug】RocketMQ在Pull模式下无法正确获取消费进度Offset
【涘涘回来啦】
09-01 4398
前两天踩了个大坑。分享记录一下爬坑过程。 现象：RocketMQ的Pull模式在cluster模式集群环境下，无法正确的获取/更新某些队列的消费进度。 为了爬坑顺着DefaultMQPullConsumer往下简单读了读代码，记录一下这里控制消费进度的大致逻辑： 1、Consumer里有一个OffsetStore，在cluster模式下的实现类是RemoteBrokerOffsetStore...
十分钟全面了解RocketMQ
小明同学
03-31 2868
RocketMQ总结 简介: RocketMQ是一款使用java编写的消息中间件，主要提供了消息发布、消息订阅、消费消息的使用功能，方便对业务进行解耦 本文将从以下几个方面介绍RocketMq 名词解释 架构与业务流程 角色功能说明 消息类型 负载均衡 名词解释 1.主题（Topic） 主题，代表某一类消息的集合，一个Topic下会有若干个消息，一个消息只属于一个Topic，是消息订阅的基本单位 Topic是逻辑上的概念，每个Topic会有多个消息队列 messageQueue，而这些消息队列又可以分布
【必会】Kafka基本概念(topic、partition、offset、broker、生产者、消费者、消费者组等)【知识点速记速查】
jiayoudangdang的博客
07-15 3726
消费者组是Kafka独有的概念，如果面试官问这个，就说明他对此是有一定了解的。官网上的介绍言简意赅，即消费者组是Kafka提供的可扩展且具有容错性的消费者机制；但实际上，消费者组(ConsumerGroup)其实包含两个概念作为队列，消费者组允许你分割数据处理到一组进程集合上(即一个消费者组中可以包含多个消费者进程，他们共同消费该topic'的数据），这有助于你的消费能力的动态调整；；在消费者组中，多个实例共同订阅若干个主题，实现共同消费。；注意；；；；，分区内消费有序；......
Rocketmq broker写入能力查看
八荒六合唯我独尊
10-20 666
如何证明 RocketMQ 集群本身没有问题呢？其实也很简单，我们通常一个常用的技巧是查看 RocketMQ 消息写入的性能，执行如下命令： cd ~/logs/rocketmqlogs/ grep 'PAGECACHERT' store.log | more 其输出的结果如下图所示： 在 RocketMQ Broker 中会每隔 1 分钟打印出上一分钟消息写入的耗时分布，例如 [<=0ms] 表示在这一秒钟写入消息在 Broker 端的延时小于 0ms 的消息条数，其他的依次类推，通
RocketMQ源码分析之拉取消息（2）
05-02 765
判断新的消息队列是否包含已经在处理的消息队列，不包含的话说明现在处理的消息队列已经不属于本实例了，所以需要剔除掉，最后删除掉该消息队列 public boolean removeUnnecessaryMessageQueue(MessageQueue mq, ProcessQueue pq) { this.defaultMQPushConsumerImpl.getOffsetStore...
消费者详解-消费进度保存机制
weixin_43248318的博客
04-08 661
文章目录消费进度保存机制定时持久化不定时持久化消费者关闭 消费进度保存机制 在 消费者详解-启动流程中我们可以知道，在消费者启动是会同时启动位点管理器，RocketMQ设计了远程位点管理-RemoteBrokerOffsetStore和本地位点管理-LocalFileOffsetStore。集群消费时，消费者使用远程位点管理-RemoteBrokerOffsetStore，将消费位点提交给Broker保存；广播消费时，消费位点保存在消费者本地磁盘上-LocalFileOffsetStore。 客户端消费进度
大揭秘！RocketMQ如何管理消费进度
博文视点（北京）官方博客
12-30 943
在企业实践RocketMQ时基本上80%都是不消费问题，而由于消费进度问题导致不消费的问题又是最难确认的和排查的。RocketMQ的消费进度分为本地消费进度管理和远程消费进度管理，分别对应的消费模式是广播消费和集群消费。 本文选自《RocketMQ分布式消息中间件：核心原理与最佳实践》一书，带你层层揭秘RocketMQ如何管理消费进度。 什么是消费进度 消费进度，也就是由Broker管理每一个消费者消费Topic的进度，包含正常提交消费进度和重置消费进度，如下： 上图表...
RocketMQ源码分析：Consumer消费偏移量
老男孩的架构路
08-08 2262
我们先看一幅图消费偏移量offset就是记录消费者的消费进度的。也是rocketmq保证消息不会重复消费的核心(当然，极端情况下还是可能会导致重复消费)。consumequeue中一个消息的索引单元就是一个offset值。在分析rocketmq的消费者是如何利用这个offset完成消息消费的之前，我们先看下broker端是如何管理这些offset值的。消费者客户端本地维护一个offset表，消费者消费完成后先更新到本地offset表中。...
kafka中offset和__consumer_offsets_理解
qq_37432174的博客
12-31 1288
记录个人学习
Consumer启动及消息消费
xxy_hl的博客
12-25 704
Consumer启动及消息消费1.DefaultMQPullConsumer启动1.获取namesrv地址2.启动网络服务3.启动定时任务1.广播模式LocalFileOffsetStore#persistAll2.集群模式4.启动消息拉取服务消息消费5.启动负载均衡服务1.消息队列分配策略2.更新processQueue 1.DefaultMQPullConsumer启动 实例化DefaultMQPullConsumer: public DefaultMQPullConsumer(final String
深入理解Kafka：Broker、Producer与Consumer解析
Consumer通过Offset来记录其在Partition中的读取进度，从而实现消息的顺序消费或重复消费。 在实际使用中，Kafka还提供了其他关键功能，如消息保留策略（可以设置消息的存活时间）、幂等性生产者（防止重复消息）...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值