RocketMQ 源码分析 —— 定时消息与消息重试

【RocketMQ】消息重试 参考 消息中间件系列教程(14) -RabbitMQ-自动补偿机制 阅读详情

点击上方“芋道源码”,选择“设为星标”

做积极的人,而不是积极废人!

源码精品专栏

 

摘要: 原创出处 http://www.iocoder.cn/RocketMQ/message-schedule-and-retry/ 「芋道源码」欢迎转载,保留摘要,谢谢!

  • 1. 概述

  • 2. 定时消息

    • 2.1 延迟级别

    • 2.2 Producer 发送定时消息

    • 2.3 Broker 存储定时消息

    • 2.4 Broker 发送定时消息

    • 2.5 Broker 持久化定时发送进度

  • 3. 消息重试


阅读源码最好的方式,是使用 IDEA 进行调试 RocketMQ 源码,不然会一脸懵逼。

胖友可以点击「芋道源码」扫码关注,回复 git001 关键字
获得艿艿添加了中文注释的 RocketMQ 源码地址。

阅读源码很孤单,加入源码交流群,一起坚持!

1. 概述

建议前置阅读内容:

  • 《RocketMQ 源码分析 —— Message 发送与接收》

  • 《RocketMQ 源码分析 —— Message 拉取与消费(下)》

???? 为什么把定时消息与消息重试放在一起?你猜。
???? 你猜我猜不猜。

2. 定时消息

定时消息是指消息发到 Broker 后,不能立刻被 Consumer 消费,要到特定的时间点或者等待特定的时间后才能被消费。

下图是定时消息的处理逻辑图:

定时消息逻辑图.png

2.1 延迟级别

RocketMQ 目前只支持固定精度的定时消息。官方说法如下:

如果要支持任意的时间精度,在 Broker 层面,必须要做消息排序,如果再涉及到持久化,那么消息排序要不可避免的产生巨大性能开销。

  • 延迟级别:

延迟级别时间
11s
25s
310s
430s
51m
62m
73m
84m
95m
106m
117m
128m
139m
1410m
1520m
1630m
171h
182h
  • 核心源码如下:

      1: // ⬇️⬇️⬇️【MessageStoreConfig.java】
      2: /**
      3:  * 消息延迟级别字符串配置
      4:  */
      5: private String messageDelayLevel = "1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h";
      6: 
      7: // ⬇️⬇️⬇️【ScheduleMessageService.java】
      8: /**
      9:  * 解析延迟级别
     10:  *
     11:  * @return 是否解析成功
     12:  */
     13: public boolean parseDelayLevel() {
     14:     HashMap<String, Long> timeUnitTable = new HashMap<>();
     15:     timeUnitTable.put("s", 1000L);
     16:     timeUnitTable.put("m", 1000L * 60);
     17:     timeUnitTable.put("h", 1000L * 60 * 60);
     18:     timeUnitTable.put("d", 1000L * 60 * 60 * 24);
     19: 
     20:     String levelString = this.defaultMessageStore.getMessageStoreConfig().getMessageDelayLevel();
     21:     try {
     22:         String[] levelArray = levelString.split(" ");
     23:         for (int i = 0; i < levelArray.length; i++) {
     24:             String value = levelArray[i];
     25:             String ch = value.substring(value.length() - 1);
     26:             Long tu = timeUnitTable.get(ch);
     27: 
     28:             int level = i + 1;
     29:             if (level > this.maxDelayLevel) {
     30:                 this.maxDelayLevel = level;
     31:             }
     32:             long num = Long.parseLong(value.substring(0, value.length() - 1));
     33:             long delayTimeMillis = tu * num;
     34:             this.delayLevelTable.put(level, delayTimeMillis);
     35:         }
     36:     } catch (Exception e) {
     37:         log.error("parseDelayLevel exception", e);
     38:         log.info("levelString String = {}", levelString);
     39:         return false;
     40:     }
     41: 
     42:     return true;
     43: }
    

2.2 Producer 发送定时消息

  • ????发送时,设置消息的延迟级别。

Message msg = new Message(...);
msg.setDelayTimeLevel(level);

2.3 Broker 存储定时消息

  • ???? 存储消息时,延迟消息进入 Topic 为 SCHEDULE_TOPIC_XXXX。

  • ???? 延迟级别 与 消息队列编号 做固定映射:QueueId = DelayLevel - 1。

核心代码如下:

  1: // ⬇️⬇️⬇️【CommitLog.java】
  2: /**
  3:  * 添加消息,返回消息结果
  4:  *
  5:  * @param msg 消息
  6:  * @return 结果
  7:  */
  8: public PutMessageResult putMessage(final MessageExtBrokerInner msg) {
  9:     // ....(省略代码) 
 10: 
 11:     // 定时消息处理
 12:     final int tranType = MessageSysFlag.getTransactionValue(msg.getSysFlag());
 13:     if (tranType == MessageSysFlag.TRANSACTION_NOT_TYPE//
 14:         || tranType == MessageSysFlag.TRANSACTION_COMMIT_TYPE) {
 15:         // Delay Delivery
 16:         if (msg.getDelayTimeLevel() > 0) {
 17:             if (msg.getDelayTimeLevel() > this.defaultMessageStore.getScheduleMessageService().getMaxDelayLevel()) {
 18:                 msg.setDelayTimeLevel(this.defaultMessageStore.getScheduleMessageService().getMaxDelayLevel());
 19:             }
 20: 
 21:             // 存储消息时,延迟消息进入 `Topic` 为 `SCHEDULE_TOPIC_XXXX` 。
 22:             topic = ScheduleMessageService.SCHEDULE_TOPIC;
 23: 
 24:             // 延迟级别 与 消息队列编号 做固定映射
 25:             queueId = ScheduleMessageService.delayLevel2QueueId(msg.getDelayTimeLevel());
 26: 
 27:             // Backup real topic, queueId
 28:             MessageAccessor.putProperty(msg, MessageConst.PROPERTY_REAL_TOPIC, msg.getTopic());
 29:             MessageAccessor.putProperty(msg, MessageConst.PROPERTY_REAL_QUEUE_ID, String.valueOf(msg.getQueueId()));
 30:             msg.setPropertiesString(MessageDecoder.messageProperties2String(msg.getProperties()));
 31: 
 32:             msg.setTopic(topic);
 33:             msg.setQueueId(queueId);
 34:         }
 35:     }
 36: 
 37:     // ....(省略代码) 
 38: }
 39: 
 40: // ⬇️⬇️⬇️【ScheduleMessageService.java】
 41: /**
 42:  * 根据 延迟级别 计算 消息队列编号
 43:  * QueueId = DelayLevel - 1
 44:  *
 45:  * @param delayLevel 延迟级别
 46:  * @return 消息队列编号
 47:  */
 48: public static int delayLevel2QueueId(final int delayLevel) {
 49:     return delayLevel - 1;
 50: }

  • ???? 生成 ConsumeQueue 时,每条消息的 tagsCode 使用【消息计划消费时间】。这样,ScheduleMessageService 在轮询 ConsumeQueue 时,可以使用 tagsCode 进行过滤。

核心代码如下:

  1: // ⬇️⬇️⬇️【CommitLog.java】
  2: /**
  3:  * check the message and returns the message size
  4:  *
  5:  * @return 0 Come the end of the file // >0 Normal messages // -1 Message checksum failure
  6:  */
  7: public DispatchRequest checkMessageAndReturnSize(ByteBuffer byteBuffer, final boolean checkCRC, final boolean readBody) {
  8:     try {
  9:         // // ....(省略代码)
 10: 
 11:         // 17 properties
 12:         short propertiesLength = byteBuffer.getShort();
 13:         if (propertiesLength > 0) {
 14:             // ....(省略代码)
 15:             String tags = propertiesMap.get(MessageConst.PROPERTY_TAGS);
 16:             if (tags != null && tags.length() > 0) {
 17:                 tagsCode = MessageExtBrokerInner.tagsString2tagsCode(MessageExt.parseTopicFilterType(sysFlag), tags);
 18:             }
 19: 
 20:             // Timing message processing
 21:             {
 22:                 String t = propertiesMap.get(MessageConst.PROPERTY_DELAY_TIME_LEVEL);
 23:                 if (ScheduleMessageService.SCHEDULE_TOPIC.equals(topic) && t != null) {
 24:                     int delayLevel = Integer.parseInt(t);
 25: 
 26:                     if (delayLevel > this.defaultMessageStore.getScheduleMessageService().getMaxDelayLevel()) {
 27:                         delayLevel = this.defaultMessageStore.getScheduleMessageService().getMaxDelayLevel();
 28:                     }
 29: 
 30:                     if (delayLevel > 0) {
 31:                         tagsCode = this.defaultMessageStore.getScheduleMessageService().computeDeliverTimestamp(delayLevel,
 32:                             storeTimestamp);
 33:                     }
 34:                 }
 35:             }
 36:         }
 37: 
 38:         // ....(省略代码)
 39: 
 40:         return new DispatchRequest(//
 41:             topic, // 1
 42:             queueId, // 2
 43:             physicOffset, // 3
 44:             totalSize, // 4
 45:             tagsCode, // 5
 46:             storeTimestamp, // 6
 47:             queueOffset, // 7
 48:             keys, // 8
 49:             uniqKey, //9
 50:             sysFlag, // 9
 51:             preparedTransactionOffset// 10
 52:         );
 53:     } catch (Exception e) {
 54:     }
 55: 
 56:     return new DispatchRequest(-1, false /* success */);
 57: }
 58: 
 59: // ⬇️⬇️⬇️【ScheduleMessageService.java】
 60: /**
 61:  * 计算 投递时间【计划消费时间】
 62:  *
 63:  * @param delayLevel 延迟级别
 64:  * @param storeTimestamp 存储时间
 65:  * @return 投递时间【计划消费时间】
 66:  */
 67: public long computeDeliverTimestamp(final int delayLevel, final long storeTimestamp) {
 68:     Long time = this.delayLevelTable.get(delayLevel);
 69:     if (time != null) {
 70:         return time + storeTimestamp;
 71:     }
 72: 
 73:     return storeTimestamp + 1000;
 74: }

2.4 Broker 发送定时消息

  • ???? 对 SCHEDULE_TOPIC_XXXX 每条消费队列对应单独一个定时任务进行轮询,发送 到达投递时间【计划消费时间】 的消息。

下图是发送定时消息的处理逻辑图:

定时消息定时逻辑

实现代码如下:

  1: /**
  2:  * ⬇️⬇️⬇️ 发送(投递)延迟消息定时任务
  3:  */
  4: class DeliverDelayedMessageTimerTask extends TimerTask {
  5:     /**
  6:      * 延迟级别
  7:      */
  8:     private final int delayLevel;
  9:     /**
 10:      * 位置
 11:      */
 12:     private final long offset;
 13: 
 14:     public DeliverDelayedMessageTimerTask(int delayLevel, long offset) {
 15:         this.delayLevel = delayLevel;
 16:         this.offset = offset;
 17:     }
 18: 
 19:     @Override
 20:     public void run() {
 21:         try {
 22:             this.executeOnTimeup();
 23:         } catch (Exception e) {
 24:             // XXX: warn and notify me
 25:             log.error("ScheduleMessageService, executeOnTimeup exception", e);
 26:             ScheduleMessageService.this.timer.schedule(new DeliverDelayedMessageTimerTask(
 27:                 this.delayLevel, this.offset), DELAY_FOR_A_PERIOD);
 28:         }
 29:     }
 30: 
 31:     /**
 32:      * 纠正可投递时间。
 33:      * 因为发送级别对应的发送间隔可以调整,如果超过当前间隔,则修正成当前配置,避免后面的消息无法发送。
 34:      *
 35:      * @param now 当前时间
 36:      * @param deliverTimestamp 投递时间
 37:      * @return 纠正结果
 38:      */
 39:     private long correctDeliverTimestamp(final long now, final long deliverTimestamp) {
 40:         long result = deliverTimestamp;
 41: 
 42:         long maxTimestamp = now + ScheduleMessageService.this.delayLevelTable.get(this.delayLevel);
 43:         if (deliverTimestamp > maxTimestamp) {
 44:             result = now;
 45:         }
 46: 
 47:         return result;
 48:     }
 49: 
 50:     public void executeOnTimeup() {
 51:         ConsumeQueue cq = ScheduleMessageService.this.defaultMessageStore.findConsumeQueue(SCHEDULE_TOPIC,  delayLevel2QueueId(delayLevel));
 52: 
 53:         long failScheduleOffset = offset;
 54: 
 55:         if (cq != null) {
 56:             SelectMappedBufferResult bufferCQ = cq.getIndexBuffer(this.offset);
 57:             if (bufferCQ != null) {
 58:                 try {
 59:                     long nextOffset = offset;
 60:                     int i = 0;
 61:                     for (; i < bufferCQ.getSize(); i += ConsumeQueue.CQ_STORE_UNIT_SIZE) {
 62:                         long offsetPy = bufferCQ.getByteBuffer().getLong();
 63:                         int sizePy = bufferCQ.getByteBuffer().getInt();
 64:                         long tagsCode = bufferCQ.getByteBuffer().getLong();
 65: 
 66:                         long now = System.currentTimeMillis();
 67:                         long deliverTimestamp = this.correctDeliverTimestamp(now, tagsCode);
 68: 
 69:                         nextOffset = offset + (i / ConsumeQueue.CQ_STORE_UNIT_SIZE);
 70: 
 71:                         long countdown = deliverTimestamp - now;
 72: 
 73:                         if (countdown <= 0) { // 消息到达可发送时间
 74:                             MessageExt msgExt = ScheduleMessageService.this.defaultMessageStore.lookMessageByOffset(offsetPy, sizePy);
 75:                             if (msgExt != null) {
 76:                                 try {
 77:                                     // 发送消息
 78:                                     MessageExtBrokerInner msgInner = this.messageTimeup(msgExt);
 79:                                     PutMessageResult putMessageResult = ScheduleMessageService.this.defaultMessageStore.putMessage(msgInner);
 80:                                     if (putMessageResult != null && putMessageResult.getPutMessageStatus() == PutMessageStatus.PUT_OK) { // 发送成功
 81:                                         continue;
 82:                                     } else { // 发送失败
 83:                                         // XXX: warn and notify me
 84:                                         log.error("ScheduleMessageService, a message time up, but reput it failed, topic: {} msgId {}", msgExt.getTopic(), msgExt.getMsgId());
 85: 
 86:                                         // 安排下一次任务
 87:                                         ScheduleMessageService.this.timer.schedule(new DeliverDelayedMessageTimerTask(this.delayLevel, nextOffset), DELAY_FOR_A_PERIOD);
 88: 
 89:                                         // 更新进度
 90:                                         ScheduleMessageService.this.updateOffset(this.delayLevel, nextOffset);
 91:                                         return;
 92:                                     }
 93:                                 } catch (Exception e) {
 94:                                     // XXX: warn and notify me
 95:                                     log.error("ScheduleMessageService, messageTimeup execute error, drop it. msgExt="
 96:                                             + msgExt + ", nextOffset=" + nextOffset + ",offsetPy=" + offsetPy + ",sizePy=" + sizePy, e);
 97:                                 }
 98:                             }
 99:                         } else {
100:                             // 安排下一次任务
101:                             ScheduleMessageService.this.timer.schedule(new DeliverDelayedMessageTimerTask(this.delayLevel, nextOffset), countdown);
102: 
103:                             // 更新进度
104:                             ScheduleMessageService.this.updateOffset(this.delayLevel, nextOffset);
105:                             return;
106:                         }
107:                     } // end of for
108: 
109:                     nextOffset = offset + (i / ConsumeQueue.CQ_STORE_UNIT_SIZE);
110: 
111:                     // 安排下一次任务
112:                     ScheduleMessageService.this.timer.schedule(new DeliverDelayedMessageTimerTask(this.delayLevel, nextOffset), DELAY_FOR_A_WHILE);
113: 
114:                     // 更新进度
115:                     ScheduleMessageService.this.updateOffset(this.delayLevel, nextOffset);
116:                     return;
117:                 } finally {
118:                     bufferCQ.release();
119:                 }
120:             } // end of if (bufferCQ != null)
121:             else { // 消费队列已经被删除部分,跳转到最小的消费进度
122:                 long cqMinOffset = cq.getMinOffsetInQueue();
123:                 if (offset < cqMinOffset) {
124:                     failScheduleOffset = cqMinOffset;
125:                     log.error("schedule CQ offset invalid. offset=" + offset + ", cqMinOffset="
126:                         + cqMinOffset + ", queueId=" + cq.getQueueId());
127:                 }
128:             }
129:         } // end of if (cq != null)
130: 
131:         ScheduleMessageService.this.timer.schedule(new DeliverDelayedMessageTimerTask(this.delayLevel, failScheduleOffset), DELAY_FOR_A_WHILE);
132:     }
133: 
134:     /**
135:      * 设置消息内容
136:      *
137:      * @param msgExt 消息
138:      * @return 消息
139:      */
140:     private MessageExtBrokerInner messageTimeup(MessageExt msgExt) {
141:         MessageExtBrokerInner msgInner = new MessageExtBrokerInner();
142:         msgInner.setBody(msgExt.getBody());
143:         msgInner.setFlag(msgExt.getFlag());
144:         MessageAccessor.setProperties(msgInner, msgExt.getProperties());
145: 
146:         TopicFilterType topicFilterType = MessageExt.parseTopicFilterType(msgInner.getSysFlag());
147:         long tagsCodeValue =
148:             MessageExtBrokerInner.tagsString2tagsCode(topicFilterType, msgInner.getTags());
149:         msgInner.setTagsCode(tagsCodeValue);
150:         msgInner.setPropertiesString(MessageDecoder.messageProperties2String(msgExt.getProperties()));
151: 
152:         msgInner.setSysFlag(msgExt.getSysFlag());
153:         msgInner.setBornTimestamp(msgExt.getBornTimestamp());
154:         msgInner.setBornHost(msgExt.getBornHost());
155:         msgInner.setStoreHost(msgExt.getStoreHost());
156:         msgInner.setReconsumeTimes(msgExt.getReconsumeTimes());
157: 
158:         msgInner.setWaitStoreMsgOK(false);
159:         MessageAccessor.clearProperty(msgInner, MessageConst.PROPERTY_DELAY_TIME_LEVEL);
160: 
161:         msgInner.setTopic(msgInner.getProperty(MessageConst.PROPERTY_REAL_TOPIC));
162: 
163:         String queueIdStr = msgInner.getProperty(MessageConst.PROPERTY_REAL_QUEUE_ID);
164:         int queueId = Integer.parseInt(queueIdStr);
165:         msgInner.setQueueId(queueId);
166: 
167:         return msgInner;
168:     }
169: }

2.5 Broker 持久化定时发送进度

  • ???? 定时消息发送进度存储在文件(../config/delayOffset.json)里

  • ???? 每 10s 定时持久化发送进度。

核心代码如下:

  1: // ⬇️⬇️⬇️【ScheduleMessageService.java】
  2: /**
  3: public void start() {
  4:     // 定时发送消息
  5:     for (Map.Entry<Integer, Long> entry : this.delayLevelTable.entrySet()) {
  6:         Integer level = entry.getKey();
  7:         Long timeDelay = entry.getValue();
  8:         Long offset = this.offsetTable.get(level);
  9:         if (null == offset) {
 10:             offset = 0L;
 11:         }
 12: 
 13:         if (timeDelay != null) {
 14:             this.timer.schedule(new DeliverDelayedMessageTimerTask(level, offset), FIRST_DELAY_TIME);
 15:         }
 16:     }
 17: 
 18:     // 定时持久化发送进度
 19:     this.timer.scheduleAtFixedRate(new TimerTask() {
 20: 
 21:         @Override
 22:         public void run() {
 23:             try {
 24:                 ScheduleMessageService.this.persist();
 25:             } catch (Exception e) {
 26:                 log.error("scheduleAtFixedRate flush exception", e);
 27:             }
 28:         }
 29:     }, 10000, this.defaultMessageStore.getMessageStoreConfig().getFlushDelayOffsetInterval());
 30: }

3. 消息重试

Consumer 消费消息失败后,要提供一种重试机制,令消息再消费一次。

  • ???? Consumer 将消费失败的消息发回 Broker,进入延迟消息队列。即,消费失败的消息,不会立即消费。

核心代码如下:

  1: // ⬇️⬇️⬇️【SendMessageProcessor.java】
  2: /**
  3:  * 消费者发回消息
  4:  *
  5:  * @param ctx ctx
  6:  * @param request 请求
  7:  * @return 响应
  8:  * @throws RemotingCommandException 当远程调用异常
  9:  */
 10: private RemotingCommand consumerSendMsgBack(final ChannelHandlerContext ctx, final RemotingCommand request)
 11:     throws RemotingCommandException {
 12:     // ....(省略代码)
 13:     // 处理 delayLevel(独有)。
 14:     int delayLevel = requestHeader.getDelayLevel();
 15:     int maxReconsumeTimes = subscriptionGroupConfig.getRetryMaxTimes();
 16:     if (request.getVersion() >= MQVersion.Version.V3_4_9.ordinal()) {
 17:         maxReconsumeTimes = requestHeader.getMaxReconsumeTimes();
 18:     }
 19:     if (msgExt.getReconsumeTimes() >= maxReconsumeTimes//
 20:     // ....(省略代码)
 21:     } else {
 22:         if (0 == delayLevel) {
 23:             delayLevel = 3 + msgExt.getReconsumeTimes();
 24:         }
 25:         msgExt.setDelayTimeLevel(delayLevel);
 26:     }
 27: 
 28:     // ....(省略代码)
 29:     return response;
 30: }


欢迎加入我的知识星球,一起探讨架构,交流源码。加入方式,长按下方二维码噢:

已在知识星球更新源码解析如下:

最近更新《芋道 SpringBoot 2.X 入门》系列,已经 20 余篇,覆盖了 MyBatis、Redis、MongoDB、ES、分库分表、读写分离、SpringMVC、Webflux、权限、WebSocket、Dubbo、RabbitMQ、RocketMQ、Kafka、性能测试等等内容。

提供近 3W 行代码的 SpringBoot 示例,以及超 4W 行代码的电商微服务项目。

获取方式:点“在看”,关注公众号并回复 666 领取,更多内容陆续奉上。

RocketMQ 一行代码造成大量消息丢失 1、问题现象 首先接到项目反馈使用 RocketMQ 会出现如下错误: 错误信息关键点:MQBrokerException:CODE:2 DESC:[TIMEOUT_CLEAN_QUEUE]broker busy,start flow control for a while,period in queue:205ms,size of queue:880。 由于项目组并没有对消息发送失败做任何补偿,导致丢失消息发送失败,故需要对这个问题进行深层次的探讨,并加以解决。 2、问题分析 首先我们根据关 阅读详情

相关推荐

RocketMQ 生产者源码分析:DefaultMQProducer、DefaultMQProducerImpl

该篇博文主要介绍生产者侧相关的类:MQProducer 能力定义者、DefaultMQProducer 能力抽象者、DefaultMQProducerImpl 能力实现者、ClientConfig RocketMQ 客户端公共的配置类,主要围绕它们内部的参数配置以及属性先初步开展介绍了一下,后续主要在启动 Producer 以及通过 Producer 发送消息时,在生产者这一侧处理的工作

vnjohn 博主 > 主线分享后端领域业务设计知识、源码思想、架构设计 3131

RocketMQ 基于时间轮算法实现指定时间点的定时消息原理解析

RocketMQ 的延时消息是指 Producer 发送消息后,Consumer 不会立即消费,而是需要等待固定的时间才能消费。在一些场景下,延时消息是很有用的,比如电商场景下关闭 30 分钟内未支付的订单。使用延时消息非常简单,只需要给消息的 delayTimeLevel 属性赋值就可以。//第 3 个级别,10s.build())//定义消息投递时间.build()).build()),RocketMQ 4.x 版本只支持延时消息,有一些局限性。

LoveSummer 2779

Python量化交易实战:如何用pytdx库快速解析通达信.day文件(附完整代码)

本文详细介绍了如何使用Python的pytdx库高效解析通达信.day本地数据文件,构建免费、稳定的量化交易数据源。文章提供了从环境配置、基础数据读取、复权处理到板块信息获取的完整实战代码,并演示了如何将处理后的数据无缝接入Backtrader等回测框架,为量化策略开发提供可靠的数据基础。

ppp33的博客 1146

RocketMQ 定时消息和重试消息

RocketMQ 支持 Producer 端发送定时消息,即该消息被发送之后,到一段时间之后才能被 Consumer 消费者端消费。但是当前开源版本的 RocketMQ 所支持的定时时间是有限的、不同级别的精度的时间,并不是任意无限制的定时时间。这 18 个定时级别在服务器端启动的时候,会被解析并放置到表 delayLevelTable 中。解析的过程就是上述字符串按照空格拆分开,然后根据时间单位的不同再进一步进行计算,得到最终的毫秒时间。i++) {// ...// 级别:延迟时间。

CoderChronicle的博客 1705

从3D相机数据到三维模型:Halcon实战深度图、亮度图与点云转换全流程

本文详细解析了如何利用Halcon将3D相机采集的深度图、亮度图转换为三维点云模型的完整流程。通过实战案例分享,涵盖数据格式处理、点云生成方法(SDK接口与纯Halcon实现)、三维模型可视化优化等关键技术,帮助工程师解决工业检测中的实际难题,提升三维重建精度与效率。

weixin_42525005的博客 397

VizCut 全自动批量视频二次去重处理!支持视频无水印解析下载和批量剪辑,完全免费,使用简单!

可制作和分享剪辑模板,已提供20+种剪辑方案,内置众多扫光蒙版素材。支持二次去重批量处理,完全免费,无广告,且支持视频无水印解析下载,非常强大。如果说我们处理的视频需要进行一样的参数设置的话,就可以把我,1设置的参数设置为模板,后面就可以一键调用。1. 本地CPU处理,可设置线程数,可开启GPU加速,无任何限制,全看机器性能。适用场景:自媒体搬运、短视频二创、批量去重等,完全免费,无广告干扰!3. 20+种参数可调可选,内置很多相关素材。可保存为模板,可复用、可分享、可导入。2. 所有参数的设置,

goodfat的博客 5333

RocketMQ5.0.0定时消息

本章节介绍延迟消息的概览,及实现机制。根据延迟级别来创建不同的定时任务,延迟到延迟级别对应的延迟时间,进行还原原始主题和消费队列,再次存储到commitlog文件中,供消费者消费。

爱我所爱0505 2340

Ansys Lumerical + HFSS + optiSLang 三剑客:手把手教你优化行波MZM调制器(附完整参数配置)

本文详细介绍了如何利用Ansys Lumerical、HFSS和optiSLang三款工具构建自动化协同设计流程,以优化行波马赫曾德尔调制器(TW-MZM)的性能。通过参数化仿真、流程集成与元模型技术,该方案能高效解决多物理场耦合挑战,实现调制带宽、驱动电压等多目标的全局优化,显著提升光子集成芯片的设计效率与性能潜力。

weixin_29251131的博客 586

深度探索RocketMQ5:定时消息新特性解析【上】

使用场景:在分布式定时调度触发、任务超时处理等场景,需要实现精准、可靠的定时事件触发。使用 Apache RocketMQ 的定时消息可以简化定时调度任务的开发逻辑,实现高性能、可扩展、高可靠的定时触发能力。(来源-官网介绍在RocketMQ5之前,并没有定时消息这个功能,只有延时消息这个类似定时消息但又不太像定时消息的功能。其中设定的延时时间只能从提供的18个定时级别中选择。RocketMQ在这个5.0这个大版本中全面拥抱云原生,在此场景下,也是支持了任意延迟时间的延迟消息功能。定时消息概述。

Azir_的博客 1296

YOLOv12涨点改进 | Neck特征融合改进篇 | YOLOv12引 入 BiFPN双向特征金字塔网络,显著提升了多尺度特征融合效率,目标检测、图像分割、图像分类,助力高效涨点

本文提出了一种基于BiFPN特征融合模块优化的YOLOv12目标检测方法。BiFPN通过引入可学习的权重实现高效的多尺度特征融合,结合双向连接机制提升特征提取能力。实验表明,该方法在COCO数据集上实现了优异的检测性能。文章详细介绍了BiFPN模块的原理、核心代码实现,以及如何将其集成到YOLOv12框架中,包括模块添加、配置文件修改等具体步骤。这种改进方案具有参数少、计算量小等优势,为高效目标检测提供了一种新的技术路径。

Ai缝合怪、助力小伙伴高效发论文 393

筑牢上线前安全防线:安全运维服务中的检测实践与深化

在日益严峻的网络安全形势下,将漏洞扫描、渗透测试和基线核查有机结合的上线前安全检测,是保障信息系统安全、稳定、合规上线的基石。通过专业、严谨、协作的检测实践,乙方安全团队能够有效协助甲方在系统生命周期的起点就构筑起坚固的安全防线,为业务的顺利开展和用户的信任保驾护航,真正实现“安全赋能业务”的价值。这道“守门人”的职责,是数字时代企业稳健前行的不可或缺的保障。专业的安全服务提供商(乙方)需要与甲方(系统所有者/运营方)建立紧密、透明、协作的伙伴关系,实现风险的闭环管理,甚至推动甲方安全能力的长期提升。

huluang的专栏 185

RocketMQ 定时/延时消息

定时消息是云消息队列 RocketMQ 版提供的一种高级消息类型,消息被发送至服务端后,在指定时间后才能被消费者消费。通过设置一定的定时时间可以实现分布式场景的延时调度触发效果。

weixin_62595121的博客 1604

如何提高电路的抗干扰能力

本内容详细介绍了电源传导干扰处理,包括滤波、Feedthrough电容器、磁环、磁珠、屏蔽的使用与选型,EMC电磁兼容测试项目简介与要求,单片机与电源抗干扰处理等。

让你爱上电路设计 8609

分布式消息队列 RocketMQ 源码分析 —— 定时消息与消息重试

摘要: 原创出处 http://www.iocoder.cn/RocketMQ/message-schedule-and-retry/ 「芋道源码」欢迎转载,保留摘要,谢谢! 本文主要基于 RocketMQ 4.0.x 正式版 1. 概述 2. 定时消息 2.1 延迟级别 2.2 Producer 发送定时消息 2.3 Broker 存储定时消息 2.4 Broker 发送定时消息 2...

芋艿V 330

C#与数据采集卡集成开发全指南:从硬件连接到实时数据处理(附工业传感器监测实战)

C#数据采集卡集成开发指南 本文系统介绍了不同类型数据采集卡(DAQ卡)与C#的集成方法。主要内容包括: 数据采集卡分类:按接口分为PCIe/PCI(高带宽低延迟)、USB(便携即插即用)和以太网(远距离组网);按信号类型分为模拟量输入、数字量输入/输出等。 C#集成核心方法: 优先使用厂商SDK(如NI DAQmx),提供完整功能封装 无SDK时采用通用协议(如USB HID、Modbus TCP) 具体实现示例: NI DAQmx采集热电偶温度代码 USB HID协议读取模拟量电压值 工业应用要点:实时

这里只有干货:从 Modbus 通信到 MES 对接,从 YOLO 训练到工控机部署,带你搞定工业软件开发全流程。 1976

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

java延迟消息队列,分布式消息队列 RocketMQ 源码分析 —— 定时消息与消息重试...

1. 概述建议前置阅读内容:《RocketMQ 源码分析 —— Message 发送与接收》《RocketMQ 源码分析 —— Message 拉取与消费(下)》为什么把定时消息与消息重试放在一起?你猜。你猜我猜不猜。2. 定时消息定时消息是指消息发到 Broker 后,不能立刻被 Consumer 消费,要到特定的时间点或者等待特定的时间后才能被消费。下图是定时消息的处理逻辑图:2.1 延迟级别...

weixin_35782626的博客 273

贝叶斯统计 [韦来生编]

贝叶斯(Bayes)统计是近几十年来迅速发展起来的数理统计的一个重要分支。贝叶斯方法与经典统计方法的主要不同之处是进行统计推断时除了利用样本信息外,还要利用参数的先验信息,因此可以提高统计推断或统计决策的效果。它在经济、金融、生物、医学、自然科学和社会科学等许多领域具有广泛的应用。贝叶斯方法的研究已渗透到了统计学的几乎所有领域。作者在给中国科学技术大学概率论与数理统计专业本科生开设的“数理统计”课程中有一章专门讲授“贝叶斯方法和统计决策理论”,近十年来也给中国科学技术大学概率统计专业研究生开设过几次“贝叶斯分析”课。本书是在对过去讲稿的内容作了适当的增减和调整的基础上完成的。  本书共分六章。第1章是绪论,介绍了贝叶斯统计的若干基本概念,同时对必要的数理统计的基础知识有重点地作了回顾。第二章介绍了确定先验分布的若干可供选择的方法。第三章介绍了几类常见统计模型参数的后验分布的主要结果和计算方法。第四章和第五章分别介绍了“贝叶斯统计推断”和“贝叶斯统计决策”的内容。第六章介绍了贝叶斯统计计算的若干方法,包括蒙特卡洛方法和马尔可夫链蒙特卡洛(MCMC)方法以及相关统计软件的简介。本书的每一章附右大量的例题和习题,书末附有常用的几个表格和部分习题解答供读者查用。  大约可在54学时内讲授本书的第1章至第六章的主要内容,教师可根据学时需要选讲本书第1章至第六章的部分内容。书中标“*”号的章节可略去不讲,留给读者作为阅读材料。第六章例题中的R代码和部分例题的数据文件等可从作者个人主页下载。  作者在编写本书的过程中参考了J.O.Berger教授的《统计决策论及贝叶斯分析》和茆诗松教授编写的《贝叶斯统计》等书中的一些内容,以及《贝叶斯分析》一书中由张伟平博士编写的有关贝叶斯统计计算的一些内容。在此表示衷心感谢。  本书编写准备过程中,中国科学技术大学统计与金融系的几个研究生帮助完成了本书部分中文的录入和排版,作者对他们的辛勤工作表示真诚的感谢。高等教育出版社为本书的出版给予了大力支持。在此一并致谢。

2、RocketMQ之生产实例源码分析原理

DefaultMQProducer是DefaultMQProducerImpl的包装类,开放给开发人员使用,DefaultMQProducer中的几乎所有的方法内部都是由DefaultMQProducerImpl实现的。这个是典型的门面模式设计模式。

qq_36851469的博客 266

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

计算机控制技术及应用

《计算机控制技术及应用》通过总结作者的科研成果和吸收国内外的先进理论、方法和技术,以计算机控制系统的网络化、开放化、智能化和集成化发展趋势为主线索,主要介绍计算机控制系统的基本概念和计算机控制系统的典型形式,计算机控制系统的数学描述与基本分析方法,以及数字PID控制器、最少拍控制系统、达林算法、状态变量设计法等设计方法及其各种改进算法。重点突出计算机控制系统输入输出通道接口的设计方法和典型控制系统的设计案例与实现方法等。

rocketmq--特性之延迟消息及消息重试

1、消息延迟级别定义     源码 MessageStoreConfig.java 是定义如下:     private String messageDelayLevel = "1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h";     可以在brocker配置     messageDelayLevel=1s 5s 10s ...

convict_EVA的专栏 3987

RocketMQ 源码合集

消息队列中间件 RocketMQ 源码分析 —— Message 发送与接收消息队列中间件 RocketMQ 源码分析 —— Message 存储分布式消息队列 RocketMQ 源码分析 —— Message 拉取与消费(上)分布式消息队列 RocketMQ 源码分析 —— Message 拉取与消费(下)分布式消息队列 RocketMQ 源码分析 —— Message 顺序发送与消费分布式消息

芋道源码 1331

消息中间件 RocketMQ 源码解析:定时消息与消息重试

原文地址:RocketMQ源码解析:定时消息与消息重试 RocketMQ 带注释地址 :YunaiV/incubator-rocketmq ��本系列每 1-2 周更新一篇,欢迎订阅、关注、收藏 GitHub。 1. 概述 2. 定时消息 2.1 延迟级别 2.2 Producer 发送定时消息 2.3 Broker 存储定时消息 2.4 Broker 发送定时消息 2.5 Brok

芋艿V 4556

RocketMQ一行代码造成大量消息发送失败

1、问题现象 首先接到项目反馈使用 RocketMQ 会出现如下错误: 错误信息关键点:MQBrokerException:CODE:2 DESC:[TIMEOUT_CLEAN_QUEUE]broker busy,start flow control for a while,period in queue:205ms,size of queue:880。 由于项目组并没有对消息发送失败做任何补偿,导致丢失消息丢失,故需要对这个问题进行深层次的探讨,并加以解决。 2、问题分析 首先我们根据关键字:TIMEO

中间件兴趣圈 2万+

RocketMQ源码分析----延时消息和重试消息的实现

延时消息的例子 和普通消息发送没多大区别,只是多了个句设置延时级别的代码 .... Message msgToBroker = new Message("topic_test", tag, id, body); msgToBroker.setDelayTimeLevel(3); .... level为3那么代表10s后消费者10s后能拉到这条消息,消费者端的代...

菜鸟一名 2126
上一篇: 芋道 Spring Boot 数据库版本管理入门
下一篇: Apache 架构师的 30 条设计原则!
公众号-芋道源码
博客等级 码龄10年 1638粉丝 377原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值