首页 文章 精选 留言 我的

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

2023-03-02 335

作者：京东物流 宫丙来

一、主从复制概述

  • 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事件，并创建HAConnection
                if ((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方法如下：

public void start() {
	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();
	}
	return this.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
public long getMaxPhyOffset() {
	return this.commitLog.getMaxOffset();
}
public long getMaxOffset() {
	return this.mappedFileQueue.getMaxOffset();
}
public long getMaxOffset() {
	MappedFile mappedFile = getLastMappedFile();
	if (mappedFile != null) {
		return mappedFile.getFileFromOffset() + mappedFile.getReadPosition();
	}
	return 0;
}

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

2.3.2、上报offset时间判断

private boolean isTimeToReportOffset() {
	//当前时间-上次写的时间
	long interval =
		HAService.this.defaultMessageStore.getSystemClock().now() - this.lastWriteTimestamp;
	boolean needHeart = 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);
			return false;
		}
	}
	return !this.reportOffset.hasRemaining();
}

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

2.4、Broker Master处理请求

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

//负责写，将commitlog数据发送到从
private WriteSocketService writeSocketService;
//负责读，读取从上报的offset，并根据offset从Broker Master读取commitlog
private 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(final long offset, final boolean returnFirstOnNotFound) {
	int mappedFileSize = this.defaultMessageStore.getMessageStoreConfig().getMapedFileSizeCommitLog();
	MappedFile mappedFile = this.mappedFileQueue.findMappedFileByOffset(offset, returnFirstOnNotFound);
	if (mappedFile != null) {
		int pos = (int) (offset % mappedFileSize);
		SelectMappedBufferResult result = mappedFile.selectMappedBuffer(pos);
		return result;
	}
	return null;
}
public SelectMappedBufferResult selectMappedBuffer(int pos) {
	int readPosition = getReadPosition();
	if (pos < readPosition && pos >= 0) {
		if (this.hold()) {
			ByteBuffer byteBuffer = this.mappedByteBuffer.slice();
			byteBuffer.position(pos);
			int size = readPosition - pos;
			ByteBuffer byteBufferNew = byteBuffer.slice();
			byteBufferNew.limit(size);
			return new SelectMappedBufferResult(this.fileFromOffset + pos, byteBufferNew, size, this);
		}
	}
	return null;
}

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

2.4.2.2、发送CommitLog数据

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

// Build Header
this.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 Body
if (!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();
		} else if (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");
		return false;
	}
}

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;


//上报从的offset
if (!reportSlaveMaxOffsetPlus()) {
	return false;

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

  1. 从byteBufferRead中读取CommitLog数据；

<!---->

  1. 调用defaultMessageStore.appendToCommitLog方法，将数据写入到MappedFile文件，写入方法如下：
public boolean appendToCommitLog(long startOffset, byte[] data) {
	//将数据写到commitlog，同普通消息的存储
	boolean result = 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；

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

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

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

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

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

public void handleHA(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 = new GroupCommitRequest(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：

public void wakeupCustomer(final boolean 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);
		return this.flushOK;
	} catch (InterruptedException e) {
		log.error("Interrupted", e);
		return false;
	}
}
}

三、元数据的复制

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

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

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


public void syncAll() {
    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.json
    this.brokerController.getTopicConfigManager().persist();
    log.info("Update slave topic config from master, {}", masterAddrBak)

3.2、syncConsumerOffset

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

3.3、syncDelayOffset

String delayOffset = this.brokerController.getBrokerOuterAPI().getAllDelayOffset(masterAddrBak);
String fileName = 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. 在功能设计的时候将元数据、程序数据分开管理；

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

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

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

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

上一篇 下一篇
优秀的个人博客,低调大师

微信关注我们

原文链接：https://my.oschina.net/u/4090830/blog/8384282

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

XView 架构升级之路

作者：京东零售 胡本奎 一 背景 1 是什么 XView是一个透明的塑料袋（容器），基于通用的webview框架改造而来，通常用于大促弹窗等营销场景，展现形式如下图： 2 痛点 在实际的开发使用中XView存在产研过程效率低，曝光率不高的2个核心痛点。 1，产研过程低效： 在研发过程中比较繁琐，不仅需要前端开发弹窗内容还需要客户端接入XView SDK以及服务端数据配置，同时依赖发版，导致交付周期长，重复工作多。 2，曝光率不高： 升级前的XView 加载流程比较长，导致曝光率不高。 3 升级 为了解决以上XView 的诸多痛点，我们将XView 弹窗进行了3个时代的升级，具体如下： 1，客户端H5弹窗组件时代: 传统的xview 只支持h5链接，这样弹窗在加载过程中存在加载速度慢，性能差，曝光率低等问题。 2，弹窗配置化时代： 通过配置弹窗可以不仅支持h5链接，同时支持图片，Gif，视频，Lottile等多种类型的素材，通过SDK 的方式，提供统一的弹窗控制，保障了弹窗的稳定性，弹窗可以通过快速配置的方式最快可以做到2个小时内测试，交付上线，同时XView CMS提供数据中心查询，可...
2023-03-02
306
上一篇

2023年了，做SEO还有必要吗？

作者：京东科技 吴磊 搜索引擎工作原理 在搜索引擎网站的后台会有一个非常庞大的数据库，里面存储了海量的关键词，而每个关键词又对应着很多网址，这些网址是被称之为“搜索引擎蜘蛛”或“网络爬虫”程序从茫茫的互联网上一点一点下载收集而来的。随着各种各样网站的出现，这些勤劳的“蜘蛛”每天在互联网上爬行，从一个链接到另一个链接，下载其中的内容，进行分析提炼，找到其中的关键词，如果“蜘蛛”认为关键词在数据库中没有而对用户是有用的便存入后台的数据库中。反之，如果“蜘蛛”认为是垃圾信息或重复信息，就舍弃不要，继续爬行，寻找最新的、有用的信息保存起来提供用户搜索。当用户搜索时，就能检索出与关键字相关的网址显示给访客。 一个关键词对用多个网址，因此就出现了排序的问题，相应的当与关键词最吻合的网址就会排在前面了。在“蜘蛛”抓取网页内容，提炼关键词的这个过程中，就存在一个问题：“蜘蛛”能否看懂。如果网站内容是flash和js等，那么它是看不懂的，会犯迷糊，即使关键字再贴切也没用。相应的，如果网站内容可以被搜索引擎能识别，那么搜索引擎就会提高该网站的权重，增加对该网站的友好度。这样一个过程我们称之为SEO。 SE...
2023-03-02
367
下一篇

相关文章

发表评论

资源下载

更多资源
优质分享App

优质分享App

近一个月的开发和优化，本站点的第一个app全新上线。该app采用极致压缩，本体才4.36MB。系统里面做了大量数据访问、缓存优化。方便用户在手机上查看文章。后续会推出HarmonyOS的适配版本。

时间: 2025-12-03 大小: 4.36MB 下载: 23次
Mario

Mario

马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长，特征是大鼻子、头戴帽子、身穿背带裤，还留着胡子。与他的双胞胎兄弟路易基一起，长年担任任天堂的招牌角色。

时间: 2025-12-12 大小: 211.28KB 下载: 54次
腾讯云软件源

腾讯云软件源

为解决软件依赖安装时官方源访问速度慢的问题，腾讯云为一些软件搭建了缓存服务。您可以通过使用腾讯云软件源站来提升依赖包的安装速度。为了方便用户自由搭建服务架构，目前腾讯云软件源站支持公网访问和内网访问。

时间: 2025-12-28 大小: 1MB 下载: 4次
Sublime Text

Sublime Text

Sublime Text具有漂亮的用户界面和强大的功能，例如代码缩略图，Python的插件，代码段等。还可自定义键绑定，菜单和工具栏。Sublime Text 的主要功能包括：拼写检查，书签，完整的 Python API ， Goto 功能，即时项目切换，多选择，多窗口等等。Sublime Text 是一个跨平台的编辑器，同时支持Windows、Linux、Mac OS X等操作系统。

时间: 2025-12-03 大小: 9.84MB 下载: 39次
手机查看

扫码在手机上查看文章

扫描二维码，手机阅读更方便

热门标签
HarmonyOS6 SpringCloud Jdk25 Docker Rocky SpringBoot4 Nacos3 Kubernetes Service Mesh Gemini3 OpenAi DeepSeek Redis

欢迎您来访！

登录后，您将获得更多功能！
热门文章
联系我们

有任何问题或合作意向欢迎联系我们

Email: 99873273@qq.com

QQ: 99873273

用户登录
用户注册