Rocketmq 故障延迟 源码解析

故障延迟

在 rocketmq 中，有两种延迟机制
1. 开启故障延迟
2. 关闭故障延迟（默认）

关闭故障延迟

通过 sendLatencyFaultEnable = false 表示关闭故障延迟
所谓的关闭故障延迟就是，在生产者发送消息的时候，可能因为网络原因或者是其他外接因素，导致消息发送失败，这个时候就会进行消息发送的重试（单向消息除外）那么在 broker 端机会记录一下这个失败的broker，所以下次轮询到这个broker 的时候就会跳过这个broker，这样就减少了消息发送失败的概率

这里关于消息发送的流程，不进行讨论，笔者会在后续博客跟新关于消息发送流程
直接来到核心的方法
TopicPublishInfo.selectOneMessageQueue(final String lastBrokerName)

 	public MessageQueue selectOneMessageQueue(final String lastBrokerName) {
        if (lastBrokerName == null) {
            return selectOneMessageQueue();
        } else {
            int index = this.sendWhichQueue.getAndIncrement();
            for (int i = 0; i < this.messageQueueList.size(); i++) {
                int pos = Math.abs(index++) % this.messageQueueList.size();
                if (pos < 0)
                    pos = 0;
                MessageQueue mq = this.messageQueueList.get(pos);
                if (!mq.getBrokerName().equals(lastBrokerName)) {
                    return mq;
                }
            }
            return selectOneMessageQueue();
        }
    }

参数 lastBrokerName : 记录上次失败的broker
这里可以看到不论是 if 还是 else 都有一个 selectOneMessageQueue()
先关注这个方法

	public MessageQueue selectOneMessageQueue() {
        int index = this.sendWhichQueue.getAndIncrement();
        int pos = Math.abs(index) % this.messageQueueList.size();
        if (pos < 0)
            pos = 0;
        return this.messageQueueList.get(pos);
    }

这里做的事情其实很简单，就是根据一个数字自增，但然后根据长度求余数，取下标对应的队列，说白了就是轮询取出队列
但是这里其实还有一些小的知识点

	private final ThreadLocal<Integer> threadLocalIndex = new ThreadLocal<Integer>();
    private final Random random = new Random();

    public int getAndIncrement() {
        Integer index = this.threadLocalIndex.get();
        if (null == index) {
            index = Math.abs(random.nextInt());
            if (index < 0)
                index = 0;
            this.threadLocalIndex.set(index);
        }
        index = Math.abs(index + 1);
        if (index < 0)
            index = 0;
        this.threadLocalIndex.set(index);
        return index;
    }

在进行这个下标自增的时候使用到了 ThreadLocal 通过线程级别的隔离，保证了这个元素的并发安全
selectOneMessageQueue 介绍完了，接下来关注else 里面的内容
else 的代码如下

 	} else {
			int index = this.sendWhichQueue.getAndIncrement();
            for (int i = 0; i < this.messageQueueList.size(); i++) {
                int pos = Math.abs(index++) % this.messageQueueList.size();
                if (pos < 0)
                    pos = 0;
                MessageQueue mq = this.messageQueueList.get(pos);
                if (!mq.getBrokerName().equals(lastBrokerName)) {
                    return mq;
                }
            }
      } 

进入else 说明了 lastBrokerName 是存在的
那么首先会对该topic 下的所有QessageQueue进行遍历
如果当前队列的brokerName 不等于 lastBrokerName，也就是说不是一个故障broker，那么就会进行return

开启故障延迟

通过 sendLatencyFaultEnable = true 表示开启故障延迟
当生产者进行发送消息的时候，收到网络的干扰发现一个broker不可用，那么就会越过这个broker，但是只能保证本次发消息是能够跳过这个broker，但是第二次发消息就不一定能能跳过这个broker
所以Rocketmq 提供了一种故障延迟机制，当发送消息出现了异常问题的时候，这个时候就会将这个broker 暂时的排除再外，也就是说，再一定时间内，这个broker 的队列不会被访问，不会选择这个broker

同样，直接来到 核心的方法
MQFaultStrategy.selectOneMessageQueue(final TopicPublishInfo tpInfo, final String lastBrokerName)

	public MessageQueue selectOneMessageQueue(final TopicPublishInfo tpInfo, final String lastBrokerName) {
        if (this.sendLatencyFaultEnable) {// 开启关闭的开关
            try {
                int index = tpInfo.getSendWhichQueue().getAndIncrement();
                for (int i = 0; i < tpInfo.getMessageQueueList().size(); i++) {
                    int pos = Math.abs(index++) % tpInfo.getMessageQueueList().size();
                    if (pos < 0)
                        pos = 0;
                    MessageQueue mq = tpInfo.getMessageQueueList().get(pos);
                    if (latencyFaultTolerance.isAvailable(mq.getBrokerName())) {
                        if (null == lastBrokerName || mq.getBrokerName().equals(lastBrokerName))
                            return mq;
                    }
                }

                final String notBestBroker = latencyFaultTolerance.pickOneAtLeast();
                int writeQueueNums = tpInfo.getQueueIdByBroker(notBestBroker);
                if (writeQueueNums > 0) {
                    final MessageQueue mq = tpInfo.selectOneMessageQueue();
                    if (notBestBroker != null) {
                        mq.setBrokerName(notBestBroker);
                        mq.setQueueId(tpInfo.getSendWhichQueue().getAndIncrement() % writeQueueNums);
                    }
                    return mq;
                } else {
                    latencyFaultTolerance.remove(notBestBroker);
                }
            } catch (Exception e) {
                log.error("Error occurred when selecting message queue", e);
            }
            return tpInfo.selectOneMessageQueue();
        }
        return tpInfo.selectOneMessageQueue(lastBrokerName);
    }

这里通过sendLatencyFaultEnable 这个变量来开启和关闭故障延迟
首先依然是选取队列，然后判断broker是不是可用的，如果是之前发送失败的broker ，那就是不可用的
这里其实笔者没有get到作者的点，因为如果broker如果可用还会进入下面一个判断
if (null == lastBrokerName || mq.getBrokerName().equals(lastBrokerName))
需要broker 的name == lastBrokerName，这让我很不解，占个坑，以后弄懂了继续跟新