rocketmq的broker如何同步信息的？
public HAService(final DefaultMessageStore defaultMessageStore) throws IOException {
this.defaultMessageStore = defaultMessageStore;
this.acceptSocketService =
new AcceptSocketService(defaultMessageStore.getMessageStoreConfig().getHaListenPort());
this.groupTransferService = new GroupTransferService();
this.haClient = new HAClient();
}
一个haservice下面有accpet和haclient分别对应客户端和服务端，grouptranserservie用来控制消息是否获取到，下面具体讲。
拿haclient举例子，在主线程做的事情
public void run() {
log.info(this.getServiceName() + " service started");
while (!this.isStopped()) {
try {
if (this.connectMaster()) {
if (this.isTimeToReportOffset()) {
boolean result = this.reportSlaveMaxOffset(this.currentReportedOffset);
if (!result) {
this.closeMaster();
}
}
this.selector.select(1000);
boolean ok = this.processReadEvent();
} else {
this.waitForRunning(1000 * 5);
}
也就是在rocketmq里面，一个具体的任务就是单独分配一个线程，从而发挥多线程优势，在主线程上面休眠等待唤醒或者超时唤醒然后执行io动作。
一个典型的基于bytebuffer的写操作，通过positon、limit来判断是否数据写完：
private boolean reportSlaveMaxOffset(final long maxOffset) {
this.reportOffset.position(0);
this.reportOffset.limit(8);
this.reportOffset.putLong(maxOffset);
this.reportOffset.position(0);
this.reportOffset.limit(8);
for (int i = 0; i < 3 && this.reportOffset.hasRemaining(); i++) {
try {
this.socketChannel.write(this.reportOffset);
} catch (IOException e) {
log.error(this.getServiceName()
+ "reportSlaveMaxOffset this.socketChannel.write exception", e);
return false;
}
}
return !this.reportOffset.hasRemaining();
}
haservice里面所有的io没有走netty，全部使用原始select做异步io，然后直接使用nio的bytebuff做read和write操作
另外rocketmq里面的每个线程实现都有一个特别的标志位：
public abstract class ServiceThread implements Runnable {
private static final InternalLogger log = InternalLoggerFactory.getLogger(LoggerName.COMMON_LOGGER_NAME);
private static final long JOIN_TIME = 90 * 1000;
protected final Thread thread;
protected final CountDownLatch2 waitPoint = new CountDownLatch2(1);
protected volatile AtomicBoolean hasNotified = new AtomicBoolean(false);
protected volatile boolean stopped = false;
这个hasnotified和countdownlatch是配合一起使用的。如果一个线程被countdown过、唤醒过，那么hasnotified就通过cas被设置成true，下一个循环进入wait的时候，不用等待超时也不用等待下一次唤醒，直接通过hasnotified这个标志位可以直接唤醒，相当于第一次唤醒我的时候 我当时没有在阻塞，那么第一次唤醒我的时候 先设置一个标示hasnotified，下次进入阻塞的时候可以直接走唤醒流程，不用等待。
下面具体讲下每个模块
HAclient:
干了两个事情：
1 备broker去nameserv注册的时候，可以从nameserv拿到master-broker的ha-address，拿到这个地址以后，通过haclient去连接master-broker。定期给主机broker上报自己的currentReportedOffset，也就是备机broker自己当前的commit-log在什么地方了
2 在channel上面尝试读取数据，这个就是主机broker发过来的具体数据提交到自己的commit-log里面。
也就是对于一个备机broker而言，发布自己的ack-offset和接收主机broker的实际数据都在ha-client一个线程完成的：
3 ha-client用到了双缓冲reallocateByteBuffer，因为主机broker发过来的数据有可能备机broker的bytebuffer已经存不下了，只能存一半，这时候需要把已经落盘的数据从bytebuffer清理掉，然后写了一半的bytebuffer从后半部分移动到前半部分，那么需要有一个第三者tmp做swap，bytebufferbackup就是这个tmp，大小跟bytebufferread一样，防止极端情况：
private void reallocateByteBuffer() {
int remain = READ_MAX_BUFFER_SIZE - this.dispatchPostion;
if (remain > 0) {
this.byteBufferRead.position(this.dispatchPostion);
this.byteBufferBackup.position(0);
this.byteBufferBackup.limit(READ_MAX_BUFFER_SIZE);
this.byteBufferBackup.put(this.byteBufferRead);
}
this.swapByteBuffer();
this.byteBufferRead.position(remain);
this.byteBufferRead.limit(READ_MAX_BUFFER_SIZE);
this.dispatchPostion = 0;
}
private void swapByteBuffer() {
ByteBuffer tmp = this.byteBufferRead;
this.byteBufferRead = this.byteBufferBackup;
this.byteBufferBackup = tmp;
}
AcceptSocketService:
干一件事：绑定端口以后，作为accpet，在主循环的select里面，监听accpet事件，如果有客户端连接进来，那么生成一个haconnection。
所以看得出来，只有主机broker才有这个accpetsocketservice和haconnection。下面具体说下HaConnection
public HAConnection(final HAService haService, final SocketChannel socketChannel) throws IOException {
this.haService = haService;
this.socketChannel = socketChannel;
this.clientAddr = this.socketChannel.socket().getRemoteSocketAddress().toString();
this.socketChannel.configureBlocking(false);
this.socketChannel.socket().setSoLinger(false, -1);
this.socketChannel.socket().setTcpNoDelay(true);
this.socketChannel.socket().setReceiveBufferSize(1024 * 64);
this.socketChannel.socket().setSendBufferSize(1024 * 64);
this.writeSocketService = new WriteSocketService(this.socketChannel);
this.readSocketService = new ReadSocketService(this.socketChannel);
this.haService.getConnectionCount().incrementAndGet();
}
socketchannel是服务端accept后拿到的、跟客户端通信的channel。
SO_LINGER选项，使用默认的
最主要的是有两个线程，一个是writesocketService一个是readSocketService
writesocketservice：当主机写入commit-log以后offset肯定会长，但是备机传过来的ack-offset没有增长。通过这种方式主机知道此时需要把什么数据传给备机。
这个线程没有双缓冲，也没有swap-bytebuffer，全部数据通过网络io写出去即可，不涉及磁盘io。这个线程平时不需要工作，只有在有新数据的时候才需要工作，啥时候被唤醒的呢？
是在service.getWaitNotifyObject().wakeupAll()业务线程进行唤醒的
readSocketService: 专门接收备机发过来的ack-offset的，收到新的ack以后，通过HAConnection.this.haService.notifyTransferSome(HAConnection.this.slaveAckOffset)唤醒GroupTransferService，后者专门处理消息是否真的已经被接收。
GroupTransferService：
双缓冲逻辑，在主循环的waitforEnding结束后的onWaitEnd中，执行swapRequests，把requestsWrite和requestsRead互换，因为这个线程在处理的时候需要用synchronnized锁整个requestsRead，别人无法put了，所以弄一个requestsWrite出来，其他线程可以在这个里面put，跟自己的线程锁住的requestsRead不冲突。
这个模块本质上就是一个thread，干两个事情：
1 在waitfoRunning中等待
2 等待超时或者被唤醒的话，那么针对requestRead里面所有request，push2SlaveMaxOffset（这个就是备机的ack-offset）大于request的offset的话，那么说明备机当前已经有这个数据了，那么wakeupCustomer把在request上的CountdownLatch去掉，并且把GroupCommitRequest的flushOK=ture。
如果备机的ack-offset比GroupCommitRequest小的话，那么循环5次等待，阻塞在notifyTransferObject，尝试等待5次看看备机的ack-offset 也就是push2SlaveMaxOffset能不能追上来，从而也让这个GroupCommitRequest的flushOK=true。
private void doWaitTransfer() {
synchronized (this.requestsRead) {
if (!this.requestsRead.isEmpty()) {
for (CommitLog.GroupCommitRequest req : this.requestsRead) {
boolean transferOK = HAService.this.push2SlaveMaxOffset.get() >= req.getNextOffset();
for (int i = 0; !transferOK && i < 5; i++) {
this.notifyTransferObject.waitForRunning(1000);
transferOK = HAService.this.push2SlaveMaxOffset.get() >= req.getNextOffset();
}
if (!transferOK) {
log.warn("transfer messsage to slave timeout, " + req.getNextOffset());
}
req.wakeupCustomer(transferOK);
}
this.requestsRead.clear();
}
}
}
那么谁在request上的countdownlatch等待呢？flushok啥含义
如果是同步master的话，两个地方：handleHA和handleDiskFlush
以前者举例子，handleHA里面：
public void handleHA(AppendMessageResult result, PutMessageResult putMessageResult, MessageExt messageExt) {
if (BrokerRole.SYNC_MASTER == this.defaultMessageStore.getMessageStoreConfig().getBrokerRole()) {
HAService service = this.defaultMessageStore.getHaService();
if (messageExt.isWaitStoreMsgOK()) {
// Determine whether to wait
if (service.isSlaveOK(result.getWroteOffset() + result.getWroteBytes())) {
GroupCommitRequest request = new GroupCommitRequest(result.getWroteOffset() + result.getWroteBytes());
service.putRequest(request);
service.getWaitNotifyObject().wakeupAll();
boolean flushOK =
request.waitForFlush(this.defaultMessageStore.getMessageStoreConfig().getSyncFlushTimeout());
if (!flushOK) {
log.error("do sync transfer other node, wait return, but failed, topic: " + messageExt.getTopic() + " tags: "
+ messageExt.getTags() + " client address: " + messageExt.getBornHostNameString());
putMessageResult.setPutMessageStatus(PutMessageStatus.FLUSH_SLAVE_TIMEOUT);
}
}
// Slave problem
else {
// Tell the producer, slave not available
putMessageResult.setPutMessageStatus(PutMessageStatus.SLAVE_NOT_AVAILABLE);
}
}
}
主机在sendmessage以后，执行service.putRequest
1 会在GroupTransferService的requestWrite里面放入新的request，让GroupTransferService去检查这个request是否已经被备机同步了
2 对GroupTransferService做waitpoint.countDown，让GroupTransferService干活必须先要唤醒他。
public synchronized void putRequest(final CommitLog.GroupCommitRequest request) {
synchronized (this.requestsWrite) {
this.requestsWrite.add(request);
}
if (hasNotified.compareAndSet(false, true)) {
waitPoint.countDown(); // notify
}
}
GroupTransferService每次被唤醒的时候，首先把requestWrite放入到requestRead里面，然后检查request的offset和备机ackoffset是否ok。
3 service.getWaitNotifyObject().wakeupAll(); 这个是唤醒writeSockeService，新的数据来了，那么写线程需要工作了。
4 在每个request上面做waitforFlush，也就是在request上面countdown等待，然后检查flushok。
所以主机上面新数据来了以后，业务线程唤醒writeSocketService去发数据给备机broker（writeSocketService通过检查commit-log的offset感知主机数据offset增长了），然后唤醒grouptransferservice去检查每个request是否已经ok。
grouptransferservice的工作没有放在writeSocketService，而是单独一个线程来做，还是利用多核并发处理。
grouptransferservice即使被业务线程在putRequest中waitPoint.countDown();被唤醒还会被this.notifyTransferObject.waitForRunning(1000)阻塞，因为被业务线程唤醒也不能表示立马可以更新request和ack-offset的关系，比较备机新的ack-offset还没来，所以还需要readSocketService在拿到新的ackoffset以后，通过this.groupTransferService.notifyTransferSome();进一步唤醒groupTransferService，此时才能真正更新request是状态flushok状态
private void doWaitTransfer() { synchronized (this.requestsRead) { if (!this.requestsRead.isEmpty()) { for (CommitLog.GroupCommitRequest req : this.requestsRead) { boolean transferOK = HAService.this.push2SlaveMaxOffset.get() >= req.getNextOffset(); for (int i = 0; !transferOK && i < 5; i++) { this.notifyTransferObject.waitForRunning(1000); transferOK = HAService.this.push2SlaveMaxOffset.get() >= req.getNextOffset(); } if (!transferOK) { log.warn("transfer messsage to slave timeout, " + req.getNextOffset()); } req.wakeupCustomer(transferOK); } this.requestsRead.clear(); } } }
