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 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h

    支持时间单位（下面有源码分析）：
    s 秒 m分钟 h小时 d天

2、使用，发送消息时设置延迟级别即可。
    Message message = new Message("TestTopic", ("Hello scheduled message " + i).getBytes());
    // This message will be delivered to consumer 10 seconds later.
    //设置延迟级别为3，就找配置的 messageDelayLevel 第三顺位，就是延迟的时间。
    message.setDelayTimeLevel(3);

源码分析：

1、默认配置
MessageStoreConfig.messageDelayLevel = "1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h";

2、延迟等级解析：
ScheduleMessageService.parseDelayLevel 方法对延迟级别做解析

public boolean parseDelayLevel() {
	HashMap<String, Long> timeUnitTable = new HashMap<String, Long>();
	timeUnitTable.put("s", 1000L);
	timeUnitTable.put("m", 1000L * 60);
	timeUnitTable.put("h", 1000L * 60 * 60);
	timeUnitTable.put("d", 1000L * 60 * 60 * 24);

	String levelString = this.defaultMessageStore.getMessageStoreConfig().getMessageDelayLevel();
	try {
		String[] levelArray = levelString.split(" ");
		for (int i = 0; i < levelArray.length; i++) {
			String value = levelArray[i];
			String ch = value.substring(value.length() - 1);
			Long tu = timeUnitTable.get(ch);

			int level = i + 1;
			if (level > this.maxDelayLevel) {
				this.maxDelayLevel = level;
			}
			long num = Long.parseLong(value.substring(0, value.length() - 1));
			long delayTimeMillis = tu * num;
			//delayLevelTable这个变量是ConcurrentMap，存放的就是延迟级别对应的延迟毫秒数。
			this.delayLevelTable.put(level, delayTimeMillis);
		}
	} catch (Exception e) {
		log.error("parseDelayLevel exception", e);
		log.info("levelString String = {}", levelString);
		return false;
	}

	return true;
}

3、CommitLog.putMessage 方法进行存储消息到commitLog 中

public PutMessageResult putMessage(final MessageExtBrokerInner msg) {

	//省略代码....

	final int tranType = MessageSysFlag.getTransactionValue(msg.getSysFlag());
	if (tranType == MessageSysFlag.TRANSACTION_NOT_TYPE
		|| tranType == MessageSysFlag.TRANSACTION_COMMIT_TYPE) {
		// Delay Delivery，延迟消息
		if (msg.getDelayTimeLevel() > 0) {
			if (msg.getDelayTimeLevel() > this.defaultMessageStore.getScheduleMessageService().getMaxDelayLevel()) {
				msg.setDelayTimeLevel(this.defaultMessageStore.getScheduleMessageService().getMaxDelayLevel());
			}
			
			//修改消息的主题为 SCHEDULE_TOPIC_XXXX
			topic = ScheduleMessageService.SCHEDULE_TOPIC;
			//修改消息的队列id为  delayLevel - 1
			queueId = ScheduleMessageService.delayLevel2QueueId(msg.getDelayTimeLevel());

			// Backup real topic, queueId，保存真实的消息主题和队列id，用来做重发
			MessageAccessor.putProperty(msg, MessageConst.PROPERTY_REAL_TOPIC, msg.getTopic());
			MessageAccessor.putProperty(msg, MessageConst.PROPERTY_REAL_QUEUE_ID, String.valueOf(msg.getQueueId()));
			msg.setPropertiesString(MessageDecoder.messageProperties2String(msg.getProperties()));

			//设置消息的主题和队列id
			msg.setTopic(topic);
			msg.setQueueId(queueId);
		}
	}
	//省略代码....
}

通过putMessage 延迟消息就被放存放到了主题为 SCHEDULE_TOPIC_XXXX 的commitlog中，后面再通过定时的方式对这这些消息进行重新发送。

4、重新发送：
生成consumerQueue 时，延迟消息使用“消息计划消费时间”当作tagCode（正常的消息使用tag 的hashCode 做为tagCode），ScheduleMessageService 在轮询 ConsumeQueue 时，可以使用 tagsCode 进行过滤。

CommitLog.checkMessageAndReturnSize 源码：

public DispatchRequest checkMessageAndReturnSize(java.nio.ByteBuffer byteBuffer, final boolean checkCRC,
        final boolean readBody) {

//省略代码...


	if (propertiesLength > 0) {
		byteBuffer.get(bytesContent, 0, propertiesLength);
		String properties = new String(bytesContent, 0, propertiesLength, MessageDecoder.CHARSET_UTF8);
		propertiesMap = MessageDecoder.string2messageProperties(properties);

		keys = propertiesMap.get(MessageConst.PROPERTY_KEYS);

		uniqKey = propertiesMap.get(MessageConst.PROPERTY_UNIQ_CLIENT_MESSAGE_ID_KEYIDX);

		String tags = propertiesMap.get(MessageConst.PROPERTY_TAGS);
		if (tags != null && tags.length() > 0) {
			//正常消息tagsCode
			tagsCode = MessageExtBrokerInner.tagsString2tagsCode(MessageExt.parseTopicFilterType(sysFlag), tags);
		}

		// Timing message processing
		{
			String t = propertiesMap.get(MessageConst.PROPERTY_DELAY_TIME_LEVEL);
			if (ScheduleMessageService.SCHEDULE_TOPIC.equals(topic) && t != null) {
				int delayLevel = Integer.parseInt(t);

				if (delayLevel > this.defaultMessageStore.getScheduleMessageService().getMaxDelayLevel()) {
					delayLevel = this.defaultMessageStore.getScheduleMessageService().getMaxDelayLevel();
				}

				if (delayLevel > 0) {
					//延迟消息tagsCode，就是投递时间
					tagsCode = this.defaultMessageStore.getScheduleMessageService().computeDeliverTimestamp(delayLevel,
						storeTimestamp);
				}
			}
		}
	}


//省略代码....		
		
}

//计算投递时间，如果设置的延迟级别找不到就默认延迟1s
public long computeDeliverTimestamp(final int delayLevel, final long storeTimestamp) {
	Long time = this.delayLevelTable.get(delayLevel);
	if (time != null) {
		return time + storeTimestamp;
	}

	return storeTimestamp + 1000;
}

5、延迟消息投递：
ScheduleMessageService 内部类 DeliverDelayedMessageTimerTask，是一个定时任务，对主题 SCHEDULE_TOPIC_XXXX 每条消费队列对应单独一个定时任务进行轮询，发送 到达投递时间“计划消费时间”的消息 

DeliverDelayedMessageTimerTask.executeOnTimeup  方法进行消息投递：

public void executeOnTimeup(){
	ConsumeQueue cq =
		ScheduleMessageService.this.defaultMessageStore.findConsumeQueue(SCHEDULE_TOPIC,
			delayLevel2QueueId(delayLevel));

	long failScheduleOffset = offset;

	if (cq != null) {
	
		//读取指定偏移处的ConsumeQueue内容
		SelectMappedBufferResult bufferCQ = cq.getIndexBuffer(this.offset);
		if (bufferCQ != null) {
			try {
				long nextOffset = offset;
				int i = 0;
				ConsumeQueueExt.CqExtUnit cqExtUnit = new ConsumeQueueExt.CqExtUnit();
				for (; i < bufferCQ.getSize(); i += ConsumeQueue.CQ_STORE_UNIT_SIZE) {
					long offsetPy = bufferCQ.getByteBuffer().getLong();
					int sizePy = bufferCQ.getByteBuffer().getInt();
					long tagsCode = bufferCQ.getByteBuffer().getLong();

					if (cq.isExtAddr(tagsCode)) {
						if (cq.getExt(tagsCode, cqExtUnit)) {
							tagsCode = cqExtUnit.getTagsCode();
						} else {
							//can't find ext content.So re compute tags code.
							log.error("[BUG] can't find consume queue extend file content!addr={}, offsetPy={}, sizePy={}",
								tagsCode, offsetPy, sizePy);
							long msgStoreTime = defaultMessageStore.getCommitLog().pickupStoreTimestamp(offsetPy, sizePy);
							tagsCode = computeDeliverTimestamp(delayLevel, msgStoreTime);
						}
					}

					long now = System.currentTimeMillis();
					
					//投递时间戳
					long deliverTimestamp = this.correctDeliverTimestamp(now, tagsCode);

					nextOffset = offset + (i / ConsumeQueue.CQ_STORE_UNIT_SIZE);

					long countdown = deliverTimestamp - now;

					if (countdown <= 0) {//tagscode 到达投递时间
						MessageExt msgExt =
							ScheduleMessageService.this.defaultMessageStore.lookMessageByOffset(offsetPy, sizePy);

						if (msgExt != null) {
							try {
								//把延迟消息组装成原始的消息
								MessageExtBrokerInner msgInner = this.messageTimeup(msgExt);
								
								//发送消息
								PutMessageResult putMessageResult =
									ScheduleMessageService.this.defaultMessageStore
										.putMessage(msgInner);
										
								if (putMessageResult != null
									&& putMessageResult.getPutMessageStatus() == PutMessageStatus.PUT_OK) {
									//发送成功
									continue;
								} else {
									//发送失败，就直接跳过这个发送失败的消息  消息就丢失
									// XXX: warn and notify me
									log.error(
										"ScheduleMessageService, a message time up, but reput it failed, topic: {} msgId {}",
										msgExt.getTopic(), msgExt.getMsgId());
									
									//重新发启一个投递任务，位置为 nextOffset
									ScheduleMessageService.this.timer.schedule(
										new DeliverDelayedMessageTimerTask(this.delayLevel,
											nextOffset), DELAY_FOR_A_PERIOD);
											
									//更新位置
									ScheduleMessageService.this.updateOffset(this.delayLevel,
										nextOffset);
									return;
								}
							} catch (Exception e) {
								/*
								 * XXX: warn and notify me
								 */
								log.error(
									"ScheduleMessageService, messageTimeup execute error, drop it. msgExt="
										+ msgExt + ", nextOffset=" + nextOffset + ",offsetPy="
										+ offsetPy + ",sizePy=" + sizePy, e);
							}
						}
					} else {
						
						//如果消息没有到达投递时间，就安排下一下任务
						ScheduleMessageService.this.timer.schedule(
							new DeliverDelayedMessageTimerTask(this.delayLevel, nextOffset),
							countdown);
						ScheduleMessageService.this.updateOffset(this.delayLevel, nextOffset);
						return;
					}
				} // end of for

				nextOffset = offset + (i / ConsumeQueue.CQ_STORE_UNIT_SIZE);
				ScheduleMessageService.this.timer.schedule(new DeliverDelayedMessageTimerTask(
					this.delayLevel, nextOffset), DELAY_FOR_A_WHILE);
				ScheduleMessageService.this.updateOffset(this.delayLevel, nextOffset);
				return;
			} finally {

				bufferCQ.release();
			}
		} // end of if (bufferCQ != null)
		else {
			//如果 读取指定偏移处的ConsumeQueue内容 为null，那么就从最小的index重新发送消息
			long cqMinOffset = cq.getMinOffsetInQueue();
			if (offset < cqMinOffset) {
				failScheduleOffset = cqMinOffset;
				log.error("schedule CQ offset invalid. offset=" + offset + ", cqMinOffset="
					+ cqMinOffset + ", queueId=" + cq.getQueueId());
			}
		}
	} // end of if (cq != null)

	ScheduleMessageService.this.timer.schedule(new DeliverDelayedMessageTimerTask(this.delayLevel,
		failScheduleOffset), DELAY_FOR_A_WHILE);
}

总结：
1、发送延迟消息时，会把原始的消息topic 修改为SCHEDULE_TOPIC_XXXX， tag为投递的时间戳；保存原始的时间消息topic，tag，目标队列
2、每一个延迟等级有一个队列，把相同的延迟等级的消息放到一个队列中，如果都放到一个队列那就不可以避免的要根据延迟等级排序，这样就很影响效率
3、每一个SCHEDULE_TOPIC_XXXX 和队列启动一个DeliverDelayedMessageTimerTask 定时任务轮询队列里面的消息，tagcode就是投递的时间戳，通过这个tagcode和当前时间对比如果小于当前时间戳就发送消息，如果大于说明时间还没有到，就启动下一次轮询任务。
4、需要注意的是，如果发送消息失败了这个消息就丢失了，只是打印了一个error日志