通过源码分析RocketMQ主从复制原理

最新推荐文章于 2024-07-04 11:00:22 发布
最新推荐文章于 2024-07-04 11:00:22 发布
阅读量170 收藏 2
点赞数
文章标签： rabbitmq Powered by 金山文档
原文链接：https://www.cnblogs.com/Jcloud/p/17170476.html
版权

一、主从复制概述

  • RocketMQ Broker的主从复制主要包括两部分内容：CommitLog的消息复制和Broker元数据的复制。

  • CommitLog的消息复制是发生在消息写入时，当消息写完Broker Master时，会通过单独的线程，将消息写入到从服务器，在写入的时候支持同步写入、异步写入两种方式。

  • Broker元数据的写入，则是Broker从服务器通过单独的线程每隔10s从主Broker上获取，然后更新从的配置，并持久化到相应的配置文件中。

  • RocketMQ主从同步一个重要的特征：主从同步不具备主从切换功能，即当主节点宕机后，从不会接管消息发送，但可以提供消息读取。

二、CommitLog消息复制

2.1、整体概述

CommitLog主从复制的流程如下：

1.Producer发送消息到Broker Master，Broker进行消息存储，并调用handleHA进行主从同步；

2.如果是同步复制的话，参考2.6章节的同步复制；

3.如果是异步复制的话，流程如下：

1. Broker Master启动，并在指定端口监听；
2. Broker Slave启动，主动连接Broker Master，通过Java NIO建立TCP连接；
3.  Broker Slave以每隔5s的间隔时间向服务端拉取消息，如果是第一次拉取的话，先获取本地CommitLog文件中最大的偏移量，以该偏移量向服务端拉取消息
4.  Broker Master 解析请求，并返回数据给Broker Slave；
5.Broker Slave收到一批消息后，将消息写入本地CommitLog文件中，然后向Master汇报拉取进度，并更新下一次待拉取偏移量；

我们先看下异步复制的整体流程，最后再看下同步复制的流程，异步复制的入口为HAService.start();

public void start() throws Exception {
 //broker master启动，接收slave请求，并处理this.acceptSocketService.beginAccept();
    this.acceptSocketService.start();
 //同步复制线程启动this.groupTransferService.start();
 //broker slave启动this.haClient.start();
}

下面分别对上面的每一步做详细说明。

2.2、HAService Master启动

public void beginAccept() throws Exception {
    this.serverSocketChannel = ServerSocketChannel.open();
    this.selector = RemotingUtil.openSelector();
    this.serverSocketChannel.socket().setReuseAddress(true);
    this.serverSocketChannel.socket().bind(this.socketAddressListen);
    this.serverSocketChannel.configureBlocking(false);
    this.serverSocketChannel.register(this.selector, SelectionKey.OP_ACCEPT);
}

在beginAccept方法中主要创建了ServerSocketChannel、Selector、设置TCP reuseAddress、绑定监听端口、设置为非阻塞模式，并注册OP_ACCEPT(连接事件)。可以看到在这里是通过Java原生的NIO来实现的，并没有通过Netty框架来实现。

acceptSocketService.start()启动方法代码如下：

while (!this.isStopped()) {
    try {
   //获取事件this.selector.select(1000);
        Set<SelectionKey> selected = this.selector.selectedKeys();
        if (selected != null) {
            for (SelectionKey k : selected) {
//处理OP_ACCEPT事件，并创建HAConnectionif ((k.readyOps() & SelectionKey.OP_ACCEPT) != 0) {
                    SocketChannel sc = ((ServerSocketChannel) k.channel()).accept();
                    if (sc != null) {
                       HAConnection conn = new HAConnection(HAService.this, sc);
                       //主要是启动readSocketService，writeSocketService这两个线程
 conn.start();
                       HAService.this.addConnection(conn);
                    }
                }
            }
            selected.clear();
        }
    } catch (Exception e) {
        log.error(this.getServiceName() + " service has exception.", e);
    }
}

选择器每1s处理一次处理一次连接就绪事件。连接事件就绪后，调用ServerSocketChannel的accept()方法创建SocketChannel，与服务端数据传输的通道。然后为每一个连接创建一个HAConnection对象，该HAConnection将负责Master-Slave数据同步逻辑。HAConnection.start方法如下：

publicvoidstart() {
	this.readSocketService.start();
	this.writeSocketService.start();
}

2.3、HAClient启动

while (!this.isStopped()) {
	try {
		//和broker master建立连接，通过java nio来实现
		if (this.connectMaster()) {
			//在心跳的同时，上报offset
			if (this.isTimeToReportOffset()) {
				//上报offset
				boolean result = this.reportSlaveMaxOffset(this.currentReportedOffset);
				if (!result) {
					this.closeMaster();
				}
			}
			this.selector.select(1000);
			//处理网络读请求，也就是处理从Master传回的消息数据
			boolean ok = this.processReadEvent();
			if (!ok) {
				this.closeMaster();
			}
			if (!reportSlaveMaxOffsetPlus()) {
				continue;
			}
			long interval =
				HAService.this.getDefaultMessageStore().getSystemClock().now()
					- this.lastWriteTimestamp;
			if (interval > HAService.this.getDefaultMessageStore().getMessageStoreConfig()
				.getHaHousekeepingInterval()) {
				log.warn("HAClient, housekeeping, found this connection[" + this.masterAddress
					+ "] expired, " + interval);
				this.closeMaster();
				log.warn("HAClient, master not response some time, so close connection");
			}
		} else {
			this.waitForRunning(1000 * 5);
		}
	} catch (Exception e) {
		log.warn(this.getServiceName() + " service has exception. ", e);
		this.waitForRunning(1000 * 5);
	}
}

2.3.1、HAService主从建立连接

如果socketChannel为空，则尝试连接Master，如果Master地址为空，返回false。

private boolean connectMaster() throws ClosedChannelException {
	if (null == socketChannel) {
		String addr = this.masterAddress.get();
		if (addr != null) {
			SocketAddress socketAddress = RemotingUtil.string2SocketAddress(addr);
			if (socketAddress != null) {
				this.socketChannel = RemotingUtil.connect(socketAddress);
				if (this.socketChannel != null) {
					//注册读事件，监听broker master返回的数据
					this.socketChannel.register(this.selector, SelectionKey.OP_READ);
				}
			}
		}
		//获取当前的offset
		this.currentReportedOffset = HAService.this.defaultMessageStore.getMaxPhyOffset();
		this.lastWriteTimestamp = System.currentTimeMillis();
	}
	returnthis.socketChannel != null;
}

  1. Broker 主从连接

Broker Slave通过NIO来进行Broker Master连接，代码如下：

SocketChannel sc = null;
sc = SocketChannel.open();
sc.configureBlocking(true);
sc.socket().setSoLinger(false, -1);
sc.socket().setTcpNoDelay(true);
sc.socket().setReceiveBufferSize(1024 * 64);
sc.socket().setSendBufferSize(1024 * 64);
sc.socket().connect(remote, timeoutMillis);
sc.configureBlocking(false);

  1. Slave获取当前offset

publiclonggetMaxPhyOffset() {
	returnthis.commitLog.getMaxOffset();
}
publiclonggetMaxOffset() {
	returnthis.mappedFileQueue.getMaxOffset();
}
publiclonggetMaxOffset() {
	MappedFile mappedFile = getLastMappedFile();
	if (mappedFile != null) {
		return mappedFile.getFileFromOffset() + mappedFile.getReadPosition();
	}
	return0;
}

可以看到最终还是通过读取MappedFile的position来获取从的offset。

2.3.2、上报offset时间判断

privatebooleanisTimeToReportOffset() {
	//当前时间-上次写的时间
	longinterval=
		HAService.this.defaultMessageStore.getSystemClock().now() - this.lastWriteTimestamp;
	booleanneedHeart= interval > HAService.this.defaultMessageStore.getMessageStoreConfig()
		.getHaSendHeartbeatInterval();


	return needHeart;
}

判断逻辑为当前时间-上次写的时间>haSendHeartbeatInterval时，则进行心跳和offset的上报。haSendHeartbeatInterval默认为5s，可配置。

2.3.3、上报offset

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);
	//最多发送三次，reportOffset是否有剩余
	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);
			returnfalse;
		}
	}
	return !this.reportOffset.hasRemaining();
}

主要还是通过NIO发送请求。

2.4、Broker Master处理请求

在主从建立连接时创建了HAConnection对象，该对象主要包含了如下两个重要的线程服务类：

//负责写，将commitlog数据发送到从private WriteSocketService writeSocketService;
//负责读，读取从上报的offset，并根据offset从Broker Master读取commitlogprivate ReadSocketService readSocketService;

2.4.1、ReadSocketService接收读请求

readSocketService.run方法如下：

while (!this.isStopped()) {
	try {
		this.selector.select(1000);
		//处理读事件
		boolean ok = this.processReadEvent();
		if (!ok) {
			HAConnection.log.error("processReadEvent error");
			break;
		}
		long interval = HAConnection.this.haService.getDefaultMessageStore().getSystemClock().now() - this.lastReadTimestamp;
		if (interval > HAConnection.this.haService.getDefaultMessageStore().getMessageStoreConfig().getHaHousekeepingInterval()) {
			log.warn("ha housekeeping, found this connection[" + HAConnection.this.clientAddr + "] expired, " + interval);
			break;
		}
	} catch (Exception e) {
		HAConnection.log.error(this.getServiceName() + " service has exception.", e);
		break;
	}
}

processReadEvent的逻辑如下：

int readSize = this.socketChannel.read(this.byteBufferRead);
if (readSize > 0) {
	readSizeZeroTimes = 0;
	this.lastReadTimestamp = HAConnection.this.haService.getDefaultMessageStore().getSystemClock().now();
	if ((this.byteBufferRead.position() - this.processPostion) >= 8) {
		int pos = this.byteBufferRead.position() - (this.byteBufferRead.position() % 8);
		//获取slave 请求的offset
		long readOffset = this.byteBufferRead.getLong(pos - 8);
		this.processPostion = pos;


		HAConnection.this.slaveAckOffset = readOffset;
		if (HAConnection.this.slaveRequestOffset < 0) {
			HAConnection.this.slaveRequestOffset = readOffset;
			log.info("slave[" + HAConnection.this.clientAddr + "] request offset " + readOffset);
		}
		//如果是同步复制的话，判断请求的offset是否push2SlaveMaxOffset相同，相同的话则唤醒master GroupTransferService
		HAConnection.this.haService.notifyTransferSome(HAConnection.this.slaveAckOffset);
	}
}

可以看到processReadEvent逻辑很简单，就是从ByteBuffer中解析出offset，然后设置HAConnection.this.slaveRequestOffset；

2.4.2、WriteSocketService进行写处理

Broker Master通过HAConnection.WriteSocketService进行CommitLog的读取，run方法主逻辑如下：

this.selector.select(1000);
//nextTransferFromWhere下次传输commitLog的起始位置if (-1 == this.nextTransferFromWhere) {
	if (0 == HAConnection.this.slaveRequestOffset) {
		long masterOffset = HAConnection.this.haService.getDefaultMessageStore().getCommitLog().getMaxOffset();
		masterOffset =
			masterOffset
				- (masterOffset % HAConnection.this.haService.getDefaultMessageStore().getMessageStoreConfig()
				.getMapedFileSizeCommitLog());


		if (masterOffset < 0) {
			masterOffset = 0;
		}


		this.nextTransferFromWhere = masterOffset;
	} else {
		this.nextTransferFromWhere = HAConnection.this.slaveRequestOffset;
	}


	log.info("master transfer data from " + this.nextTransferFromWhere + " to slave[" + HAConnection.this.clientAddr
		+ "], and slave request " + HAConnection.this.slaveRequestOffset);
}


//获取commitLog数据
SelectMappedBufferResult selectResult = HAConnection.this.haService.getDefaultMessageStore().getCommitLogData(this.nextTransferFromWhere);
//获取commitLog数据
SelectMappedBufferResult selectResult =
	HAConnection.this.haService.getDefaultMessageStore().getCommitLogData(this.nextTransferFromWhere);
if (selectResult != null) {
	int size = selectResult.getSize();
	if (size > HAConnection.this.haService.getDefaultMessageStore().getMessageStoreConfig().getHaTransferBatchSize()) {
		size = HAConnection.this.haService.getDefaultMessageStore().getMessageStoreConfig().getHaTransferBatchSize();
	}


	long thisOffset = this.nextTransferFromWhere;
	this.nextTransferFromWhere += size;


	selectResult.getByteBuffer().limit(size);
	this.selectMappedBufferResult = selectResult;


	// Build Header
	this.byteBufferHeader.position(0);
	this.byteBufferHeader.limit(headerSize);
	this.byteBufferHeader.putLong(thisOffset);
	this.byteBufferHeader.putInt(size);
	this.byteBufferHeader.flip();
	//nio发送commitlog
	this.lastWriteOver = this.transferData();
} else {
    //如果没有获取到commitLog数据，等待100ms
	HAConnection.this.haService.getWaitNotifyObject().allWaitForRunning(1

这里面主要包括获取CommitLog数据、发送CommitLog数据这两个步骤。

2.4.2.1、获取CommitLog数据

public SelectMappedBufferResult getData(finallong offset, finalboolean returnFirstOnNotFound) {
	intmappedFileSize=this.defaultMessageStore.getMessageStoreConfig().getMapedFileSizeCommitLog();
	MappedFilemappedFile=this.mappedFileQueue.findMappedFileByOffset(offset, returnFirstOnNotFound);
	if (mappedFile != null) {
		intpos= (int) (offset % mappedFileSize);
		SelectMappedBufferResultresult= mappedFile.selectMappedBuffer(pos);
		return result;
	}
	returnnull;
}
public SelectMappedBufferResult selectMappedBuffer(int pos) {
	intreadPosition= getReadPosition();
	if (pos < readPosition && pos >= 0) {
		if (this.hold()) {
			ByteBufferbyteBuffer=this.mappedByteBuffer.slice();
			byteBuffer.position(pos);
			intsize= readPosition - pos;
			ByteBufferbyteBufferNew= byteBuffer.slice();
			byteBufferNew.limit(size);
			returnnewSelectMappedBufferResult(this.fileFromOffset + pos, byteBufferNew, size, this);
		}
	}
	returnnull;
}

可以看到最终还是根据offset从MappedFile读取数据。

2.4.2.2、发送CommitLog数据

数据主要包括header、body两部分，数据发送的话还是通过NIO来实现，主要代码如下：

// Build Headerthis.byteBufferHeader.position(0);
this.byteBufferHeader.limit(headerSize);
this.byteBufferHeader.putLong(thisOffset);
this.byteBufferHeader.putInt(size);
this.byteBufferHeader.flip();


int writeSize = this.socketChannel.write(this.byteBufferHeader);
// Write Bodyif (!this.byteBufferHeader.hasRemaining()) {
	while (this.selectMappedBufferResult.getByteBuffer().hasRemaining()) {
		int writeSize = this.socketChannel.write(this.selectMappedBufferResult.getByteBuffer());
		if (writeSize > 0) {
			writeSizeZeroTimes = 0;
			this.lastWriteTimestamp = HAConnection.this.haService.getDefaultMessageStore().getSystemClock().now();
		} elseif (writeSize == 0) {
			if (++writeSizeZeroTimes >= 3) {
				break;
			}
		} else {
			throw new Exception("ha master write body error < 0");
		}
	}
}

CommitLog主从发送完成后，Broker Slave则会监听读事件、获取CommitLog数据，并进行CommitLog的写入。

2.5、HAClient processReadEvent

在主从建立连接后，从注册了可读事件，目的就是读取从Broker Master返回的CommitLog数据，对应的方法为HAClient.processReadEvent：

int readSize = this.socketChannel.read(this.byteBufferRead);
if (readSize > 0) {
	lastWriteTimestamp = HAService.this.defaultMessageStore.getSystemClock().now();
	readSizeZeroTimes = 0;
	boolean result = this.dispatchReadRequest();
	if (!result) {
		log.error("HAClient, dispatchReadRequest error");
		returnfalse;
	}
}

dispatchReadRequest方法如下：

//读取返回的body data
byte[] bodyData = new byte[bodySize];
this.byteBufferRead.position(this.dispatchPostion + msgHeaderSize);
this.byteBufferRead.get(bodyData);


HAService.this.defaultMessageStore.appendToCommitLog(masterPhyOffset, bodyData);


this.byteBufferRead.position(readSocketPos);
this.dispatchPostion += msgHeaderSize + bodySize;


//上报从的offsetif (!reportSlaveMaxOffsetPlus()) {
	returnfalse;

里面的核心逻辑主要包括如下三个步骤：

  1. 从byteBufferRead中读取CommitLog数据；

  1. 调用defaultMessageStore.appendToCommitLog方法，将数据写入到MappedFile文件，写入方法如下：

publicbooleanappendToCommitLog(long startOffset, byte[] data) {
	//将数据写到commitlog，同普通消息的存储
	booleanresult=this.commitLog.appendData(startOffset, data);
	//唤醒reputMessageService，构建consumeQueue,index
	this.reputMessageService.wakeup();
	return result;
}

  1. 上报从新的offset，也是读取MappedFile的offset，然后上报Broker Master；

2.6、同步复制

上面主要介绍了Broker的异步复制，下面再来看下Broker的同步复制的实现。同步复制的整体流程图如下：

大概说明如下：

  1. producer发送消息到broker，broker进行消息的存储，将消息写入到commitLog；

  1. broker master写消息线程唤醒WriteSocketService线程，查询commitLog数据，然后发送到从。在WriteSocketService获取commitLog时，如果没有获取到commitLog数据，会等待100ms。所以当commitLog新写入数据的时候，会唤醒WriteSocketService，然后查询commitLog数据，发送到从。

  1. broker master创建GroupCommitRequest，同步等待主从复制完成；

  1. 从接受新的commitLog数据，然后写commitLog数据，并返回新的slave offset到主；

  1. 主更新push2SlaveMaxOffset，并判断push2SlaveMaxOffset是否大于等于主从复制请求的offset，如果大于等于的话，则认为主从复制完成，返回commitLog.handleHA方法成功，从而返回消息保存成功。

对应的代码入口为CommitLog.handleHA方法。

publicvoidhandleHA(AppendMessageResult result, PutMessageResult putMessageResult, MessageExt messageExt){
	//如果是broker主，并且是同步复制的话
	if (BrokerRole.SYNC_MASTER == this.defaultMessageStore.getMessageStoreConfig().getBrokerRole()) {
		//获取HAService
		HAService service = this.defaultMessageStore.getHaService();
		//获取Message上的MessageConst.PROPERTY_WAIT_STORE_MSG_OK，默认是需要等待主从复制完成
		if (messageExt.isWaitStoreMsgOK()) {
			/**
			 * 判断从是否可用，判断的逻辑是：（主offset-push2SlaveMaxOffset<1024 * 1024 * 256），也就是如果主从的offset差的太多，
			 * 则认为从不可用， Tell the producer, slave not available
			 * 这里的result = mappedFile.appendMessage(msg, this.appendMessageCallback);
			 */
			if (service.isSlaveOK(result.getWroteOffset() + result.getWroteBytes())) {
				//组装GroupCommitRequest，nextOffset=result.getWroteOffset() + result.getWroteBytes()，这里的nextOffset指的就是从要写到的offset
				GroupCommitRequest request = newGroupCommitRequest(result.getWroteOffset() + result.getWroteBytes());
				                    /**
                * 调用的是this.groupTransferService.putRequest(request);将request放到requestsWrite list中。
                  * HAService持有GroupTransferService groupTransferService引用;
                */
				service.putRequest(request);
				 /**
                     * 唤醒的是WriteSocketService，查询commitLog数据，然后发送到从。
                     * 在WriteSocketService获取commitLog时，如果没有获取到commitLog数据，等待100ms
                     * HAConnection.this.haService.getWaitNotifyObject().allWaitForRunning(100);
                     * 所以当commitLog新写入数据的时候，会唤醒WriteSocketService，然后查询commitLog数据，发送到从。
                     */
				service.getWaitNotifyObject().wakeupAll();


				//等待同步复制完成，判断逻辑是： HAService.this.push2SlaveMaxOffset.get() >= req.getNextOffset();
				boolean flushOK =
					request.waitForFlush(this.defaultMessageStore.getMessageStoreConfig().getSyncFlushTimeout());


				//如果同步复制失败的话，设置putMessageResult中的状态为同步从超时
				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);
			}
		}
	}

2.6.1、GroupTransferService启动

在HAService启动的时候，启动了GroupTransferService线程，代码如下：

public void run() {
	while (!this.isStopped()) {
		this.waitForRunning(10);
		this.doWaitTransfer();
	}
}
private void doWaitTransfer() {
	synchronized (this.requestsRead) {
		if (!this.requestsRead.isEmpty()) {
			for (CommitLog.GroupCommitRequest req : this.requestsRead) {
				/**
				 * req.getNextOffset：result.getWroteOffset() + result.getWroteBytes()
				 * push2SlaveMaxOffset：
				 */
				boolean transferOK = HAService.this.push2SlaveMaxOffset.get() >= req.getNextOffset();
				//在这循环5次，最多等待5s，因为slave 心跳间隔默认5s
				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());
				}
				//主从复制完成，唤醒handleHA后续操作
                req.wakeupCustomer(transferOK);
			}
			this.requestsRead.clear();
		}
	}
}

wakeupCustomer：

publicvoidwakeupCustomer(finalboolean flushOK) {
    this.flushOK = flushOK;
    this.countDownLatch.countDown();
}

2.6.2、唤醒WriteSocketService

service.getWaitNotifyObject().wakeupAll();

唤醒的是WriteSocketService，查询commitLog数据，然后发送到从。在WriteSocketService获取commitLog时，如果没有获取到commitLog数据，等待100ms。HAConnection.this.haService.getWaitNotifyObject().allWaitForRunning(100);所以当commitLog新写入数据的时候，会唤醒WriteSocketService，然后查询commitLog数据，发送到从。

2.6.3、同步等待，直到复制完成

boolean flushOK =
	request.waitForFlush(this.defaultMessageStore.getMessageStoreConfig().getSyncFlushTimeout());


public boolean waitForFlush(long timeout) {
	try {
		//等待同步复制完成
		this.countDownLatch.await(timeout, TimeUnit.MILLISECONDS);
		returnthis.flushOK;
	} catch (InterruptedException e) {
		log.error("Interrupted", e);
		returnfalse;
	}
}
}

三、元数据的复制

broker元数据的复制，主要包括topicConfig、consumerOffset、delayOffset、subscriptionGroup这几部分，整体流程图如下：

从broker通过单独的线程，每隔10s进行一次元数据的复制 ，代码入口为：BrokerController.start -> SlaveSynchronize.syncAll：

slaveSyncFuture = this.scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
    @Override
    publicvoidrun() {
        try {
            //10s 进行一次主从同步
            BrokerController.this.slaveSynchronize.syncAll();
        }
        catch (Throwable e) {
            log.error("ScheduledTask SlaveSynchronize syncAll error.", e);
        }
    }
}, 1000 * 3, 1000 * 10, TimeUnit.MILLISECONDS);


publicvoidsyncAll() {
    this.syncTopicConfig();
    this.syncConsumerOffset();
    this.syncDelayOffset();
    this.syncSubscriptionGroupConfig();
}

3.1、syncTopicConfig

//从Master获取TopicConfig信息，最终调用的是AdminBrokerProcessor.getAllTopicConfig
TopicConfigSerializeWrapper topicWrapper =
    this.brokerController.getBrokerOuterAPI().getAllTopicConfig(masterAddrBak);
if (!this.brokerController.getTopicConfigManager().getDataVersion()
    .equals(topicWrapper.getDataVersion())) {
    this.brokerController.getTopicConfigManager().getDataVersion()
        .assignNewOne(topicWrapper.getDataVersion());
    this.brokerController.getTopicConfigManager().getTopicConfigTable().clear();
    this.brokerController.getTopicConfigManager().getTopicConfigTable()
        .putAll(topicWrapper.getTopicConfigTable());
 //将topicConfig进行持久化，对应的文件为topics.jsonthis.brokerController.getTopicConfigManager().persist();
    log.info("Update slave topic config from master, {}", masterAddrBak)

3.2、syncConsumerOffset

//从"主Broker"获取ConsumerOffset
ConsumerOffsetSerializeWrapper offsetWrapper =
        this.brokerController.getBrokerOuterAPI().getAllConsumerOffset(masterAddrBak);
//设置从的offsetTablethis.brokerController.getConsumerOffsetManager().getOffsetTable()
                    .putAll(offsetWrapper.getOffsetTable());
//并持久化到从的consumerOffset.json文件中this.brokerController.getConsumerOffsetManager().persist();

3.3、syncDelayOffset

StringdelayOffset=this.brokerController.getBrokerOuterAPI().getAllDelayOffset(masterAddrBak);
StringfileName= StorePathConfigHelper.getDelayOffsetStorePath(this.brokerController
.getMessageStoreConfig().getStorePathRootDir());
 MixAll.string2File(delayOffset, fileName);

3.4、syncSubscriptionGroupConfig

SubscriptionGroupWrapper subscriptionWrapper =this.brokerController.getBrokerOuterAPI().getAllSubscriptionGroupConfig(masterAddrBak);
SubscriptionGroupManager subscriptionGroupManager =this.brokerController.getSubscriptionGroupManager();
subscriptionGroupManager.getDataVersion().assignNewOne(subscriptionWrapper.getDataVersion());
subscriptionGroupManager.getSubscriptionGroupTable().clear();
subscriptionGroupManager.getSubscriptionGroupTable().putAll(subscriptionWrapper.getSubscriptionGroupTable());
subscriptionGroupManager.persist();

四、思考与收获

通过上面的分享，我们基本上了解了RocketMQ的主从复制原理，其中有些思想我们可以后续借鉴下：

  1. 在功能设计的时候将元数据、程序数据分开管理；

  1. 主从复制的时候，基本思想都是从请求主，请求时带上offset，然后主查询数据返回从，从再执行；mysql的主从复制、redis的主从复制基本也是这样；

  1. 主从复制包括异步复制、同步复制两种方式，可以通过配置来决定使用哪种同步方式，这个需要根据实际业务场景来决定；

  1. 主从复制线程尽量和消息写线程或者主线程分开；

由于时间、精力有限，难免会有纰漏、考虑不到之处，如有问题欢迎沟通、交流。

cn--萍诚1号
关注
RocketMQ主从复制原理解析（Java源码分析）
TechWhiz的博客
09-15 60
总结而言，RocketMQ主从复制是一种关键的分布式架构模式，通过将消息复制到多个从节点，实现了消息的可靠传输和高可用性。此外，主从复制还可以用于数据的冗余备份和负载均衡，通过将数据复制到多个从节点，提高系统的并发处理能力和吞吐量。在DefaultMessageStore类的构造函数中，会初始化主从复制相关的配置参数，如从节点的IP和端口号。CommitLog类是RocketMQ中的核心类之一，负责消息的存储和复制。在CommitLog的构造函数中，会初始化主从复制相关的配置参数，如主节点的IP和端口号。
我理解的RocketMQ：主从复制HA(high availability)的机制分析
xiaojkql的博客
01-17 439
1 概述 主从消息复制方式：RocketMQ中主从同步采用的是主节点主动向从节点发送同步消息，是由一个后台不断运行的线程执行。注意是后台。并不是生产者给主Broker发送消息，主Broker处理接收消息时进行显示调用同步消息给从Broker。 从Broker向主Broker反馈主从消息复制进度：从Broker定时的向主Broker反馈复制消息进度。主Broker便知道从Broker的消息复制进度。这个反馈主要是用来实现主从同步复制。 发送消息同步的方式进行主从消息复制的实现：主Broker在处理接收消息时，
RocketMQ-Broker(五)-主从同步机制
星光之子的博客
12-08 2610
Broker主从同步机制主从同步概述主从同步流程相关名词配置数据同步流程CommitLog数据同步流程异步复制同步复制 主从同步概述 Master主要用于处理生产者、消费者的请求和存储数据 Slave从Master同步所有数据到本地，具体作用提现如下： Broker服务高可用。一般生产环境不会部署两个主Broker节点和两个从Broker节点（也叫 2m2s），一个 Master宕机后，另一个 Master可以接管工作；如果两个 Master都宕机，消费者可以通过连接Slave继续消费。这样可以保证服务的
RocketMQ中的主从复制
多看多听多总结
11-13 2130
1、组件结构图
RocketMQ中主从复制
小泽
02-29 653
生产者把消息发送到master，不会发送到slave 消费者可以从maste也可以从slave消费消息 如果master挂了，那就从slave消费数据，那么slave怎么拿到master中的数据 这就要用到主从复制 ...
RocketMQ源码分析之主从数据复制
不爱学习的小妞博客
04-26 924
文章目录前言一、元数据复制二、commitlog复制1.启动master并监听slave连接2.启动slave，建立与master连接及向master发送待拉取数据的物理偏移量3.master根据待拉取数据的物理偏移量打包数据并发给slave3.1 master读取数据3.2 master向slave写数据4.slave读取master发送的数据包5.总结三、同步复制与异步复制四、元数据复制与commitlog复制对比 前言 在RocketMQ主从架构中master和slave之间会进行数据同步，其中数据
RocketMQ 主从复制原理深度解析
最新发布
Xiaohong0716的博客
07-04 1136
1、主从复制包含元数据复制和消息数据复制两个部分；2、元数据复制​ Slave Broker 定时任务每隔 10 秒向 Master Broker 发送 RPC 请求，将元数据同步到缓存后，然后持久化到磁盘里；3、消息数据复制Master 启动监听指定端口Slave 启动 HaClient 服务，和 Master 创建 TCP 链接Slave 向 Master 上报存储进度Master 接收进度，消息文件中检索该偏移量后的所有消息，并传输给 Slave。
RocketMQ主从同步配置
LeoBiggU的博客
04-10 1989
前言 前面我们在需要在VMware下搭建Linux简易局域网集群？手把手教你搞定一文中搭建了 一个Win10+CentOS7局域网集群，且其各个CentOS之间可以免密钥访问，其IP信息如下： 集群IP分配表 系统 网关 IP 子网掩码 Windows10 192.168.2.1 192.168.2.2...
RocketMQ源码：主从同步实现原理(HA)
Java技术攻略的博客
04-17 227
主从同步的实现逻辑主要在中，在的构造函数中，对进行了实例化，并在start方法中，启动了： 在的构造函数中，创建了、和，在start方法中主要做了如下几件事： 的方法里面首先获取了，然后进行端口绑定，并在selector上面注册了事件的监听，监听从节点的连接请求： 2. 处理从节点连接请求 的run方法中，对监听到的连接请求进行了处理，处理逻辑大致如下： 3. 等待主从复制传输结束 的主要是为了在进行。在运行时首先进会调用进行等待，因为此时可能还有没有开始主从同步，所以先进行等待，之后如
源码研究RocketMQ主从同步机制(HA)，顺利通过阿里Java岗面试
m0_65484584的博客
12-20 216
2.1 Master启动流程（HAService） public void start() throws Exception { this.acceptSocketService.beginAccept(); this.acceptSocketService.start(); this.groupTransferService.start(); this.haClient.start(); } public void start() throws Exception { this.acceptSocket.
RocketMQ主从同步
chongshui129727的博客
08-06 1081
RocketMQ作为一款优秀的分布式消息中间件，分布式系统的一个很重要的特点就是要保证系统的高可用(HA)，RocketMQ则是通过主从同步机制保证系统的高可用。 1、概述 主从同步同步的是啥作为消息中间件，无疑是消息相当于给数据做**”备份“**，主节点服务器Broker宕机后，消费者可以从...
MQSQL的主从复制&读写分离
qq_42292373的博客
10-28 419
文章目录分表分库的几种形式垂直拆分水平拆分水平拆分的数据库访问 分表分库的几种形式 垂直拆分 一个数据库由很多表的构成，每个表对应着不同的业务，垂直切分是指按照业务将表进行分类， 分布到不同的数据库上面，这样也就将数据或者说压力分担到不同的库上面，如下图： 简单的说：一个服务有多个模块，每个模块对应着一个数据库，每个数据库对应着每个表 优点： 1. 拆分后业务清晰...
RocketMQ5.0源码分析-Broker主备自主切换组件AutoSwitchHAService图文详解
BASK2311的博客
10-26 585
RocketMQ5.0主备自主切换是在RocketMQ4.x的基础上增加了epoch等一些设计，同时依赖DLedger实现选主。主要负责接口对外，AutoSwitchHAService提供实际的服务编排，将不同的服务编排起来实现整个功能。作者：蚂蚁背大象链接：https://juejin.cn/post/7156987666951569421来源：稀土掘金著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
源码研究RocketMQ主从同步机制(HA)
中间件兴趣圈
03-18 8477
HA主从同步的核心类图如图所示： 1、初始RocketMQ HA HAService：主从同步核心实现类。 1）AtomicInteger connectionCount：Master维护的连接数。（Slave的个数）。 2）List connectionList：具体连接信息。 3）AcceptSocketService acceptSocketService：服务端接收连接线程实...
8. Broker-主从同步机制
mitsui_wang的博客
11-08 410
主从同步机制 为了提高消息的高可用性，避免单点故障导致消息不能消费，rocketmq引入了主从同步机制，如果broker主宕机后，消费者可以继续从broker从拉取消息。rocketmq主从同步由HAService实现的，原理为： 1.master启动在特定端口监听slave连接 2.slave和master建立连接后，指定拉取消息的偏移量 3.slave保存master传过来的消息，反馈...
rocketmq源码解析broker启动④
chucuavins01156的专栏
08-24 241
说在前面 源码解析 进入方法，构建索引，org.apache.rocketmq.store.index.IndexService#buildIndex public void buildIndex(DispatchRequest req) {// 试着获取并创建索...
RocketMQ MappedFile设计思路
Wengzhengcun的博客
06-15 1148
然而，内存映射文件也有一定的局限性，如地址空间的大小受到操作系统的限制，因此对于非常大的文件可能无法完整映射到内存中。需要注意的是，在选择回收的物理内存页时，操作系统会考虑这个页的使用情况，如是否被修改（脏页）。虚拟内存管理是操作系统中的一种内存管理技术，它允许程序拥有独立的、连续的地址空间，并将这些地址空间映射到物理内存和磁盘上的存储资源。避免了额外的内存拷贝：当我们从磁盘文件读取数据时，如果不使用内存映射文件，数据需要先从磁盘读取到操作系统的缓冲区，然后再从缓冲区拷贝到Java堆内存中。
RocketMQ
weixin_56892092的博客
05-13 485
官方文档：https://github.com/apache/rocketmq/blob/master/docs/cn 中文的很爽 1.AKF拆分 和Kafka一样，broker，topic拆分模式是一样的 2.元数据模型 1. HDFS RocketMQ 汇报模型，每个部分维护自己的元数据，最终汇报给一个主Master 在HDFS中为NameNode，最后对外提供一个可用的元数据列表 2. Kafka 元数据统一维护，所有节点一致，ZK有元数据，每个节点有M..
RocketMQ源码(十一)—Broker 消息重放服务ReputMessageService源码解析
djdjdxieuej的博客
01-15 431
本次我们学习了ReputMessageService消息重放服务的总体流程，下一篇文章我们将深入学习CommitLogDispatcherBuildConsumeQueue、CommitLogDispatcherBuildIndex到底是如何构建异步构建ConsumeQueue和IndexFile索引文件的。
RocketMQ 4.9.3 版本源码分析
2. 可靠性：提供消息持久化机制，并通过主从复制技术来保证消息的高可靠性。RocketMQ还具备消息投递的可靠性保障，包括消息的重试机制和消息的确认机制。 3. 分布式设计：支持消息的分布式存储和负载均衡，具备良好...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值