【RocketMQ】主從同步實現原理

shanml發表於2022-12-05

主從同步的實現邏輯主要在HAService中，在DefaultMessageStore的建構函式中，對HAService進行了例項化，並在start方法中，啟動了HAService：

public class DefaultMessageStore implements MessageStore {
    public DefaultMessageStore(final MessageStoreConfig messageStoreConfig, final BrokerStatsManager brokerStatsManager,
        final MessageArrivingListener messageArrivingListener, final BrokerConfig brokerConfig) throws IOException {
        // ...
        if (!messageStoreConfig.isEnableDLegerCommitLog()) {
            // 初始化HAService
            this.haService = new HAService(this);
        } else {
            this.haService = null;
        }
        // ...
    }

    public void start() throws Exception {
        // ...
        if (!messageStoreConfig.isEnableDLegerCommitLog()) {
            // 啟動HAService
            this.haService.start();
            this.handleScheduleMessageService(messageStoreConfig.getBrokerRole());
        }
        // ...
    }
}

在HAService的建構函式中，建立了AcceptSocketService、GroupTransferService和HAClient，在start方法中主要做了如下幾件事：

呼叫AcceptSocketService的beginAccept方法，這一步主要是進行埠繫結，在埠上監聽從節點的連線請求（可以看做是執行在master節點的）;
呼叫AcceptSocketService的start方法啟動服務，這一步主要為了處理從節點的連線請求，與從節點建立連線（可以看做是執行在master節點的）;
呼叫GroupTransferService的start方法，主要用於在主從同步的時候，等待資料傳輸完畢（可以看做是執行在master節點的）;
呼叫HAClient的start方法啟動，裡面與master節點建立連線，向master彙報主從同步進度並儲存master傳送過來的同步資料（可以看做是執行在從節點的）;

public class HAService {
     public HAService(final DefaultMessageStore defaultMessageStore) throws IOException {
        this.defaultMessageStore = defaultMessageStore;
        // 建立AcceptSocketService
        this.acceptSocketService =
            new AcceptSocketService(defaultMessageStore.getMessageStoreConfig().getHaListenPort());
        this.groupTransferService = new GroupTransferService();
        // 建立HAClient
        this.haClient = new HAClient();
    }

    public void start() throws Exception {
        // 開始監聽從伺服器的連線
        this.acceptSocketService.beginAccept();
        // 啟動服務
        this.acceptSocketService.start();
        // 啟動GroupTransferService
        this.groupTransferService.start();
        // 啟動
        this.haClient.start();
    }
}

監聽從節點連線請求

AcceptSocketService的beginAccept方法裡面首先獲取了ServerSocketChannel，然後進行埠繫結，並在selector上面註冊了OP_ACCEPT事件的監聽，監聽從節點的連線請求：

public class HAService {
    class AcceptSocketService extends ServiceThread {
        /**
         * 監聽從節點的連線
         *
         * @throws Exception If fails.
         */
        public void beginAccept() throws Exception {
            // 建立ServerSocketChannel
            this.serverSocketChannel = ServerSocketChannel.open();
            // 獲取selector
            this.selector = RemotingUtil.openSelector();
            this.serverSocketChannel.socket().setReuseAddress(true);
            // 繫結埠
            this.serverSocketChannel.socket().bind(this.socketAddressListen);
            // 設定非阻塞
            this.serverSocketChannel.configureBlocking(false);
            // 註冊OP_ACCEPT連線事件的監聽
            this.serverSocketChannel.register(this.selector, SelectionKey.OP_ACCEPT);
        }
    }
}

處理從節點連線請求

AcceptSocketService的run方法中，對監聽到的連線請求進行了處理，處理邏輯大致如下：

從selector中獲取到監聽到的事件；
如果是OP_ACCEPT連線事件，建立與從節點的連線物件HAConnection，與從節點建立連線，然後呼叫HAConnection的start方法進行啟動，並建立的HAConnection物件加入到連線集合中，HAConnection中封裝了Master節點和從節點的資料同步邏輯；

public class HAService {
    class AcceptSocketService extends ServiceThread {
        @Override
        public void run() {
            log.info(this.getServiceName() + " service started");
            // 如果服務未停止
            while (!this.isStopped()) {
                try {
                    this.selector.select(1000);
                    // 獲取監聽到的事件
                    Set<SelectionKey> selected = this.selector.selectedKeys();
                    // 處理事件
                    if (selected != null) {
                        for (SelectionKey k : selected) {
                            // 如果是連線事件
                            if ((k.readyOps() & SelectionKey.OP_ACCEPT) != 0) {
                                SocketChannel sc = ((ServerSocketChannel) k.channel()).accept();
                                if (sc != null) {
                                    HAService.log.info("HAService receive new connection, "
                                        + sc.socket().getRemoteSocketAddress());
                                    try {
                                        // 建立HAConnection，建立連線
                                        HAConnection conn = new HAConnection(HAService.this, sc);
                                        // 啟動
                                        conn.start();
                                        // 新增連線
                                        HAService.this.addConnection(conn);
                                    } catch (Exception e) {
                                        log.error("new HAConnection exception", e);
                                        sc.close();
                                    }
                                }
                            } else {
                                log.warn("Unexpected ops in select " + k.readyOps());
                            }
                        }
                        selected.clear();
                    }
                } catch (Exception e) {
                    log.error(this.getServiceName() + " service has exception.", e);
                }
            }
            log.info(this.getServiceName() + " service end");
        }
    }
}

等待主從複製傳輸結束

GroupTransferService的run方法主要是為了在進行主從資料同步的時候，等待從節點資料同步完畢。

在執行時首先進會呼叫waitForRunning進行等待，因為此時可能還有沒有開始主從同步，所以先進行等待，之後如果有同步請求，會喚醒該執行緒，然後呼叫doWaitTransfer方法等待資料同步完成：

public class HAService {
    class GroupTransferService extends ServiceThread {

         public void run() {
            log.info(this.getServiceName() + " service started");
            // 如果服務未停止
            while (!this.isStopped()) {
                try {
                    // 等待執行
                    this.waitForRunning(10);
                    // 如果被喚醒，呼叫doWaitTransfer等待主從同步完成
                    this.doWaitTransfer();
                } catch (Exception e) {
                    log.warn(this.getServiceName() + " service has exception. ", e);
                }
            }

            log.info(this.getServiceName() + " service end");
        }
    }
}

在看doWaitTransfer方法之前，首先看下是如何判斷有資料需要同步的。

Master節點中，當訊息被寫入到CommitLog以後，會呼叫submitReplicaRequest方法處主從同步，首先判斷當前Broker的角色是否是SYNC_MASTER，如果是則會構建訊息提交請求GroupCommitRequest，然後呼叫HAService的putRequest新增到請求集合中，並喚醒GroupTransferService中在等待的執行緒：

public class CommitLog {
    public CompletableFuture<PutMessageStatus> submitReplicaRequest(AppendMessageResult result, MessageExt messageExt) {
        if (BrokerRole.SYNC_MASTER == this.defaultMessageStore.getMessageStoreConfig().getBrokerRole()) {
            HAService service = this.defaultMessageStore.getHaService();
            if (messageExt.isWaitStoreMsgOK()) {
                if (service.isSlaveOK(result.getWroteBytes() + result.getWroteOffset())) {
                    // 構建GroupCommitRequest
                    GroupCommitRequest request = new GroupCommitRequest(result.getWroteOffset() + result.getWroteBytes(),
                            this.defaultMessageStore.getMessageStoreConfig().getSlaveTimeout());
                    // 新增請求
                    service.putRequest(request);
                    // 喚醒GroupTransferService中在等待的執行緒
                    service.getWaitNotifyObject().wakeupAll();
                    return request.future();
                }
                else {
                    return CompletableFuture.completedFuture(PutMessageStatus.SLAVE_NOT_AVAILABLE);
                }
            }
        }
        return CompletableFuture.completedFuture(PutMessageStatus.PUT_OK);
    }
}

在doWaitTransfer方法中，會判斷CommitLog提交請求集合requestsRead是否為空，如果不為空，表示有訊息寫入了CommitLog，Master節點需要等待將資料傳輸給從節點：

push2SlaveMaxOffset記錄了從節點已經同步的訊息偏移量，判斷push2SlaveMaxOffset是否大於本次CommitLog提交的偏移量，也就是請求中設定的偏移量；
獲取請求中設定的等待截止時間；
開啟迴圈，判斷資料是否還未傳輸完畢，並且未超過截止時間，如果是則等待1s，然後繼續判斷傳輸是否完畢，不斷進行，直到超過截止時間或者資料已經傳輸完畢；
（向從節點傳送的訊息最大偏移量push2SlaveMaxOffset超過了請求中設定的偏移量表示本次同步資料傳輸完畢）；
喚醒在等待資料同步完畢的執行緒；

public class HAService {
    // CommitLog提交請求集合
    private volatile LinkedList<CommitLog.GroupCommitRequest> requestsRead = new LinkedList<>();

    class GroupTransferService extends ServiceThread {

        private void doWaitTransfer() {
            // 如果CommitLog提交請求集合不為空
            if (!this.requestsRead.isEmpty()) {
                // 處理訊息提交請求
                for (CommitLog.GroupCommitRequest req : this.requestsRead) {
                    // 判斷傳輸到從節點最大偏移量是否超過了請求中設定的偏移量
                    boolean transferOK = HAService.this.push2SlaveMaxOffset.get() >= req.getNextOffset();
                    // 獲取截止時間
                    long deadLine = req.getDeadLine();
                    // 如果從節點還未同步完畢並且未超過截止時間
                    while (!transferOK && deadLine - System.nanoTime() > 0) {
                        // 等待
                        this.notifyTransferObject.waitForRunning(1000);
                        // 判斷從節點同步的最大偏移量是否超過了請求中設定的偏移量
                        transferOK = HAService.this.push2SlaveMaxOffset.get() >= req.getNextOffset();
                    }
                    // 喚醒
                    req.wakeupCustomer(transferOK ? PutMessageStatus.PUT_OK : PutMessageStatus.FLUSH_SLAVE_TIMEOUT);
                }

                this.requestsRead = new LinkedList<>();
            }
        }
    }
}

啟動HAClient

HAClient可以看做是在從節點上執行的，主要進行的處理如下：

呼叫connectMaster方法連線Master節點，Master節點上也會執行，但是它本身就是Master沒有可連的Master節點，所以可以忽略；
呼叫isTimeToReportOffset方法判斷是否需要向Master節點彙報同步偏移量，如果需要則呼叫reportSlaveMaxOffset方法將當前的訊息同步偏移量傳送給Master節點；
呼叫processReadEvent處理網路請求中的可讀事件，也就是處理Master傳送過來的訊息，將訊息存入CommitLog；

public class HAService {
    class HAClient extends ServiceThread {
   
        @Override
        public void run() {
            log.info(this.getServiceName() + " service started");
            while (!this.isStopped()) {
                try {
                    // 連線Master節點
                    if (this.connectMaster()) {
                        // 是否需要報告訊息同步偏移量
                        if (this.isTimeToReportOffset()) {
                            // 向Master節點傳送同步偏移量
                            boolean result = this.reportSlaveMaxOffset(this.currentReportedOffset);
                            if (!result) {
                                this.closeMaster();
                            }
                        }
                        this.selector.select(1000);
                        // 處理讀事件，也就是Master節點傳送的資料
                        boolean ok = this.processReadEvent();
                        if (!ok) {
                            this.closeMaster();
                        }
                        // ...
                    } else {
                        this.waitForRunning(1000 * 5);
                    }
                } catch (Exception e) {
                    log.warn(this.getServiceName() + " service has exception. ", e);
                    this.waitForRunning(1000 * 5);
                }
            }

            log.info(this.getServiceName() + " service end");
        }
    }
}

連線主節點

connectMaster方法中會獲取Master節點的地址，並轉換為SocketAddress物件，然後向Master節點請求建立連線，並在selector註冊OP_READ可讀事件監聽：

public class HAService {
    class HAClient extends ServiceThread {
    // 當前的主從複製進度
    private long currentReportedOffset = 0;

    private boolean connectMaster() throws ClosedChannelException {
        if (null == socketChannel) {
            String addr = this.masterAddress.get();
            if (addr != null) {
                // 將地址轉為SocketAddress
                SocketAddress socketAddress = RemotingUtil.string2SocketAddress(addr);
                if (socketAddress != null) {
                    // 連線master
                    this.socketChannel = RemotingUtil.connect(socketAddress);
                    if (this.socketChannel != null) {
                        // 註冊OP_READ可讀事件監聽
                        this.socketChannel.register(this.selector, SelectionKey.OP_READ);
                    }
                }
            }
            // 獲取CommitLog中當前最大的偏移量
            this.currentReportedOffset = HAService.this.defaultMessageStore.getMaxPhyOffset();
            // 更新上次寫入時間
            this.lastWriteTimestamp = System.currentTimeMillis();
        }
        return this.socketChannel != null;
    }
}

傳送主從同步訊息拉取偏移量

在isTimeToReportOffset方法中，首先獲取當前時間與上一次進行主從同步的時間間隔interval，如果時間間隔interval大於配置的傳送心跳時間間隔，表示需要向Master節點傳送從節點訊息同步的偏移量，接下來會呼叫reportSlaveMaxOffset方法傳送同步偏移量，也就是說從節點會定時向Master節點傳送請求，反饋CommitLog中同步訊息的偏移量：

public class HAService {
    class HAClient extends ServiceThread {
       // 當前從節點已經同步訊息的偏移量大小
       private long currentReportedOffset = 0;

       private boolean isTimeToReportOffset() {
            // 獲取距離上一次主從同步的間隔時間
            long interval =
                HAService.this.defaultMessageStore.getSystemClock().now() - this.lastWriteTimestamp;
            // 判斷是否超過了配置的傳送心跳包時間間隔
            boolean needHeart = interval > HAService.this.defaultMessageStore.getMessageStoreConfig()
                .getHaSendHeartbeatInterval();

            return needHeart;
        }

        // 傳送同步偏移量,傳入的引數是當前的主從複製偏移量currentReportedOffset
        private boolean reportSlaveMaxOffset(final long maxOffset) {
            this.reportOffset.position(0);
            this.reportOffset.limit(8); // 設定資料傳輸大小為8個位元組
            this.reportOffset.putLong(maxOffset);// 設定同步偏移量
            this.reportOffset.position(0);
            this.reportOffset.limit(8);

            for (int i = 0; i < 3 && this.reportOffset.hasRemaining(); i++) {
                try {
                    // 向Master節點傳送拉取偏移量
                    this.socketChannel.write(this.reportOffset);
                } catch (IOException e) {
                    log.error(this.getServiceName()
                        + "reportSlaveMaxOffset this.socketChannel.write exception", e);
                    return false;
                }
            }
            // 更新傳送時間
            lastWriteTimestamp = HAService.this.defaultMessageStore.getSystemClock().now();
            return !this.reportOffset.hasRemaining();
        }
    }
}

處理網路可讀事件

processReadEvent方法中處理了可讀事件，也就是處理Master節點傳送的同步資料，首先從socketChannel中讀取資料到byteBufferRead中，byteBufferRead是讀緩衝區，讀取資料的方法會返回讀取到的位元組數，對位元組數大小進行判斷：

如果可讀位元組數大於0表示有資料需要處理，呼叫dispatchReadRequest方法進行處理;
如果可讀位元組數為0表示沒有可讀資料，此時記錄讀取到空資料的次數，如果連續讀到空資料的次數大於3次，將終止本次處理;

  class HAClient extends ServiceThread {
        // 讀緩衝區，會將從socketChannel讀入緩衝區
        private ByteBuffer byteBufferRead = ByteBuffer.allocate(READ_MAX_BUFFER_SIZE);

        private boolean processReadEvent() {
            int readSizeZeroTimes = 0;
            while (this.byteBufferRead.hasRemaining()) {
                try {
                    // 從socketChannel中讀取資料到byteBufferRead中，返回讀取到的位元組數
                    int readSize = this.socketChannel.read(this.byteBufferRead);
                    if (readSize > 0) {
                        // 重置readSizeZeroTimes
                        readSizeZeroTimes = 0;
                        // 處理資料
                        boolean result = this.dispatchReadRequest();
                        if (!result) {
                            log.error("HAClient, dispatchReadRequest error");
                            return false;
                        }
                    } else if (readSize == 0) {
                        // 記錄讀取到空資料的次數
                        if (++readSizeZeroTimes >= 3) {
                            break;
                        }
                    } else {
                        log.info("HAClient, processReadEvent read socket < 0");
                        return false;
                    }
                } catch (IOException e) {
                    log.info("HAClient, processReadEvent read socket exception", e);
                    return false;
                }
            }

            return true;
        }
  }

訊息寫入ComitLog

dispatchReadRequest方法中會將從節點讀取到的資料寫入CommitLog，dispatchPosition記錄了已經處理的資料在讀緩衝區中的位置，從讀緩衝區byteBufferRead獲取剩餘可讀取的位元組數，如果可讀資料的位元組數大於一個訊息頭的位元組數（12個位元組），表示有資料還未處理完畢，反之表示訊息已經處理完畢結束處理。
對資料的處理邏輯如下：

從緩衝區中讀取資料，首先獲取到的是訊息在master節點的物理偏移量masterPhyOffset；
向後讀取8個位元組，得到訊息體內容的位元組數bodySize；
獲取從節點當前CommitLog的最大物理偏移量slavePhyOffset，如果不為0並且不等於masterPhyOffset，表示與Master節點的傳輸偏移量不一致，也就是資料不一致，此時終止處理；
如果可讀取的位元組數大於一個訊息頭的位元組數 + 訊息體大小，表示有訊息可處理，繼續進行下一步；
計算訊息體在讀緩衝區中的起始位置，從讀緩衝區中根據起始位置，讀取訊息內容，將訊息追加到從節點的CommitLog中；
更新dispatchPosition的值為訊息頭大小 + 訊息體大小，dispatchPosition之前的資料表示已經處理完畢；

    class HAClient extends ServiceThread {
        // 已經處理的資料在讀緩衝區中的位置,初始化為0
        private int dispatchPosition = 0;
        // 讀緩衝區
        private ByteBuffer byteBufferRead = ByteBuffer.allocate(READ_MAX_BUFFER_SIZE);

        private boolean dispatchReadRequest() {
            // 訊息頭大小
            final int msgHeaderSize = 8 + 4; // phyoffset + size
            // 開啟迴圈不斷讀取資料
            while (true) {
                // 獲可讀取的位元組數
                int diff = this.byteBufferRead.position() - this.dispatchPosition;
                // 如果位元組數大於一個訊息頭的位元組數
                if (diff >= msgHeaderSize) {
                    // 獲取訊息在master節點的物理偏移量
                    long masterPhyOffset = this.byteBufferRead.getLong(this.dispatchPosition);
                    // 獲取訊息體大小
                    int bodySize = this.byteBufferRead.getInt(this.dispatchPosition + 8);
                    // 獲取從節點當前CommitLog的最大物理偏移量
                    long slavePhyOffset = HAService.this.defaultMessageStore.getMaxPhyOffset();
                    if (slavePhyOffset != 0) {
                        // 如果不一致結束處理
                        if (slavePhyOffset != masterPhyOffset) {
                            log.error("master pushed offset not equal the max phy offset in slave, SLAVE: "
                                + slavePhyOffset + " MASTER: " + masterPhyOffset);
                            return false;
                        }
                    }
                    // 如果可讀取的位元組數大於一個訊息頭的位元組數 + 訊息體大小
                    if (diff >= (msgHeaderSize + bodySize)) {
                        // 將度緩衝區的資料轉為位元組陣列
                        byte[] bodyData = byteBufferRead.array();
                        // 計算訊息體在讀緩衝區中的起始位置
                        int dataStart = this.dispatchPosition + msgHeaderSize;
                        // 從讀緩衝區中根據訊息的位置，讀取訊息內容，將訊息追加到從節點的CommitLog中
                        HAService.this.defaultMessageStore.appendToCommitLog(
                                masterPhyOffset, bodyData, dataStart, bodySize);
                        // 更新dispatchPosition的值為訊息頭大小+訊息體大小
                        this.dispatchPosition += msgHeaderSize + bodySize;
                        if (!reportSlaveMaxOffsetPlus()) {
                            return false;
                        }
                        continue;
                    }
                }
                if (!this.byteBufferRead.hasRemaining()) {
                    this.reallocateByteBuffer();
                }

                break;
            }

            return true;
        }
    }

HAConnection

HAConnection中封裝了Master節點與從節點的網路通訊處理，分別在ReadSocketService和WriteSocketService中。

ReadSocketService

ReadSocketService啟動後處理監聽到的可讀事件，前面知道HAClient中從節點會定時向Master節點彙報從節點的訊息同步偏移量，Master節點對彙報請求的處理就在這裡，如果從網路中監聽到了可讀事件，會呼叫processReadEvent處理讀事件：

public class HAConnection {
     class ReadSocketService extends ServiceThread {
        @Override
        public void run() {
            HAConnection.log.info(this.getServiceName() + " service started");
            while (!this.isStopped()) {
                try {
                    this.selector.select(1000);
                    // 處理可讀事件
                    boolean ok = this.processReadEvent();
                    if (!ok) {
                        HAConnection.log.error("processReadEvent error");
                        break;
                    }
                    // ...
                } catch (Exception e) {
                    HAConnection.log.error(this.getServiceName() + " service has exception.", e);
                    break;
                }
            }
            // ...
            HAConnection.log.info(this.getServiceName() + " service end");
        }
     }
}

處理可讀事件

processReadEvent中從網路中處理讀事件的方式與上面HAClient的dispatchReadRequest類似，都是將網路中的資料讀取到讀緩衝區中，並用一個變數記錄已讀取資料的位置，processReadEvent方法的處理邏輯如下：

從socketChannel讀取資料到讀緩衝區byteBufferRead中，返回讀取到的位元組數；
如果讀取到的位元組數大於0，進入下一步，如果讀取到的位元組數為0，記錄連續讀取到空位元組數的次數是否超過三次，如果超過終止處理；
判斷剩餘可讀取的位元組數是否大於等於8，前面知道，從節點傳送同步訊息拉取偏移量的時候設定的位元組大小為8，所以位元組數大於等於8的時候表示需要讀取從節點傳送的偏移量；
計算資料在緩衝區中的位置，從緩衝區讀取從節點傳送的同步偏移量readOffset；
更新processPosition的值，processPosition表示讀緩衝區中已經處理資料的位置；
更新slaveAckOffset為從節點傳送的同步偏移量readOffset的值；
如果當前Master節點記錄的從節點的同步偏移量slaveRequestOffset小於0，表示還未進行同步，此時將slaveRequestOffset更新為從節點傳送的同步偏移量；
如果從節點傳送的同步偏移量比當前Master節點的最大物理偏移量還要大，終止本次處理；
呼叫notifyTransferSome，更新Master節點記錄的向從節點同步訊息的偏移量；

public class HAConnection {

     class ReadSocketService extends ServiceThread {
     // 讀緩衝區    
     private final ByteBuffer byteBufferRead = ByteBuffer.allocate(READ_MAX_BUFFER_SIZE);
     // 讀緩衝區中已經處理的資料位置
     private int processPosition = 0;

     private boolean processReadEvent() {
            int readSizeZeroTimes = 0;
            // 如果沒有可讀資料
            if (!this.byteBufferRead.hasRemaining()) {
                this.byteBufferRead.flip();
                // 處理位置置為0
                this.processPosition = 0;
            }
            // 如果資料未讀取完畢
            while (this.byteBufferRead.hasRemaining()) {
                try {
                    // 從socketChannel讀取資料到byteBufferRead中，返回讀取到的位元組數
                    int readSize = this.socketChannel.read(this.byteBufferRead);
                    // 如果讀取資料位元組數大於0
                    if (readSize > 0) {
                        // 重置readSizeZeroTimes
                        readSizeZeroTimes = 0;
                        // 獲取上次處理讀事件的時間戳
                        this.lastReadTimestamp = HAConnection.this.haService.getDefaultMessageStore().getSystemClock().now();
                        // 判斷剩餘可讀取的位元組數是否大於等於8
                        if ((this.byteBufferRead.position() - this.processPosition) >= 8) {
                            // 獲取偏移量內容的結束位置
                            int pos = this.byteBufferRead.position() - (this.byteBufferRead.position() % 8);
                            // 從結束位置向前讀取8個位元組得到從點傳送的同步偏移量
                            long readOffset = this.byteBufferRead.getLong(pos - 8);
                            // 更新處理位置
                            this.processPosition = pos;
                            // 更新slaveAckOffset為從節點傳送的同步進度
                            HAConnection.this.slaveAckOffset = readOffset;
                            // 如果記錄的從節點的同步進度小於0，表示還未進行同步
                            if (HAConnection.this.slaveRequestOffset < 0) {
                                // 更新為從節點傳送的同步進度
                                HAConnection.this.slaveRequestOffset = readOffset;
                                log.info("slave[" + HAConnection.this.clientAddr + "] request offset " + readOffset);
                            } else if (HAConnection.this.slaveAckOffset > HAConnection.this.haService.getDefaultMessageStore().getMaxPhyOffset()) {
                                // 如果從節點傳送的拉取偏移量比當前Master節點的最大物理偏移量還要大
                                log.warn("slave[{}] request offset={} greater than local commitLog offset={}. ",
                                        HAConnection.this.clientAddr,
                                        HAConnection.this.slaveAckOffset,
                                        HAConnection.this.haService.getDefaultMessageStore().getMaxPhyOffset());
                                return false;
                            }
                            // 更新Master節點記錄的向從節點同步訊息的偏移量
                            HAConnection.this.haService.notifyTransferSome(HAConnection.this.slaveAckOffset);
                        }
                    } else if (readSize == 0) 
                        // 判斷連續讀取到空資料的次數是否超過三次
                        if (++readSizeZeroTimes >= 3) {
                            break;
                        }
                    } else {
                        log.error("read socket[" + HAConnection.this.clientAddr + "] < 0");
                        return false;
                    }
                } catch (IOException e) {
                    log.error("processReadEvent exception", e);
                    return false;
                }
            }

            return true;
        }
    }
}

前面在GroupTransferService中可以看到是透過push2SlaveMaxOffset的值判斷本次同步是否完成的，在notifyTransferSome方法中可以看到當Master節點收到從節點反饋的訊息拉取偏移量時，對push2SlaveMaxOffset的值進行了更新：

public class HAService {
    // 向從節點推送的訊息最大偏移量
    private final GroupTransferService groupTransferService;

    public void notifyTransferSome(final long offset) {
        // 如果傳入的偏移大於push2SlaveMaxOffset記錄的值，進行更新
        for (long value = this.push2SlaveMaxOffset.get(); offset > value; ) {
            // 更新向從節點推送的訊息最大偏移量
            boolean ok = this.push2SlaveMaxOffset.compareAndSet(value, offset);
            if (ok) {
                this.groupTransferService.notifyTransferSome();
                break;
            } else {
                value = this.push2SlaveMaxOffset.get();
            }
        }
    }
}

WriteSocketService

WriteSocketService用於Master節點向從節點傳送同步訊息，處理邏輯如下：

根據從節點傳送的主從同步訊息拉取偏移量slaveRequestOffset進行判斷：
- 如果slaveRequestOffset值為-1，表示還未收到從節點報告的同步偏移量，此時睡眠一段時間等待從節點傳送訊息拉取偏移量；
- 如果slaveRequestOffset值不為-1，表示已經開始進行主從同步進行下一步；
判斷nextTransferFromWhere值是否為-1，nextTransferFromWhere記錄了下次需要傳輸的訊息在CommitLog中的偏移量，如果值為-1表示初次進行資料同步，此時有兩種情況：
- 如果從節點傳送的拉取偏移量slaveRequestOffset為0，就從當前CommitLog檔案最大偏移量開始同步；
- 如果slaveRequestOffset不為0，則從slaveRequestOffset位置處進行資料同步；
判斷上次寫事件是否已經將資料都寫入到從節點
- 如果已經寫入完畢，判斷距離上次寫入資料的時間間隔是否超過了設定的心跳時間，如果超過，為了避免連線空閒被關閉，需要傳送一個心跳包，此時構建心跳包的請求資料，呼叫transferData方法傳輸資料；
- 如果上次的資料還未傳輸完畢，呼叫transferData方法繼續傳輸，如果還是未完成，則結束此處處理；
根據nextTransferFromWhere從CommitLog中獲取訊息，如果未獲取到訊息，等待100ms，如果獲取到訊息，從CommitLog中獲取訊息進行傳輸：
（1）如果獲取到訊息的位元組數大於最大傳輸的大小，設定最最大傳輸數量，分批進行傳輸；
（2）更新下次傳輸的偏移量地址也就是nextTransferFromWhere的值；
（3）從CommitLog中獲取的訊息內容設定到將讀取到的訊息資料設定到selectMappedBufferResult中；
（4）設定訊息頭資訊，包括訊息頭位元組數、拉取訊息的偏移量等；
（5）呼叫transferData傳送資料；

public class HAConnection {
    class WriteSocketService extends ServiceThread {
        private final int headerSize = 8 + 4;// 訊息頭大小
        @Override
        public void run() {
            HAConnection.log.info(this.getServiceName() + " service started");
            while (!this.isStopped()) {
                try {
                    this.selector.select(1000);
                    // 如果slaveRequestOffset為-1，表示還未收到從節點報告的拉取進度
                    if (-1 == HAConnection.this.slaveRequestOffset) {
                        // 等待一段時間
                        Thread.sleep(10);
                        continue;
                    }
                    // 初次進行資料同步
                    if (-1 == this.nextTransferFromWhere) {
                        // 如果拉取進度為0
                        if (0 == HAConnection.this.slaveRequestOffset) {
                            // 從master節點最大偏移量從開始傳輸
                            long masterOffset = HAConnection.this.haService.getDefaultMessageStore().getCommitLog().getMaxOffset();
                            masterOffset =
                                masterOffset
                                    - (masterOffset % HAConnection.this.haService.getDefaultMessageStore().getMessageStoreConfig()
                                    .getMappedFileSizeCommitLog());

                            if (masterOffset < 0) {
                                masterOffset = 0;
                            }
                            // 更新nextTransferFromWhere
                            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);
                    }
                    // 判斷上次傳輸是否完畢
                    if (this.lastWriteOver) {
                        // 獲取當前時間距離上次寫入資料的時間間隔
                        long interval =
                            HAConnection.this.haService.getDefaultMessageStore().getSystemClock().now() - this.lastWriteTimestamp;
                        // 如果距離上次寫入資料的時間間隔超過了設定的心跳時間
                        if (interval > HAConnection.this.haService.getDefaultMessageStore().getMessageStoreConfig()
                            .getHaSendHeartbeatInterval()) {
                            // 構建header
                            this.byteBufferHeader.position(0);
                            this.byteBufferHeader.limit(headerSize);
                            this.byteBufferHeader.putLong(this.nextTransferFromWhere);
                            this.byteBufferHeader.putInt(0);
                            this.byteBufferHeader.flip();
                            // 傳送心跳包
                            this.lastWriteOver = this.transferData();
                            if (!this.lastWriteOver)
                                continue;
                        }
                    } else {
                        // 未傳輸完畢，繼續上次的傳輸
                        this.lastWriteOver = this.transferData();
                        // 如果依舊未完成，結束本次處理
                        if (!this.lastWriteOver)
                            continue;
                    }
                    // 根據偏移量獲取訊息資料
                    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);
                        // 將讀取到的訊息資料設定到selectMappedBufferResult
                        this.selectMappedBufferResult = selectResult;

                        // 設定訊息頭
                        this.byteBufferHeader.position(0);
                        // 設定訊息頭大小
                        this.byteBufferHeader.limit(headerSize);
                        // 設定偏移量地址
                        this.byteBufferHeader.putLong(thisOffset);
                        // 設定訊息內容大小
                        this.byteBufferHeader.putInt(size);
                        this.byteBufferHeader.flip();
                        // 傳送資料
                        this.lastWriteOver = this.transferData();
                    } else {
                        // 等待100ms
                        HAConnection.this.haService.getWaitNotifyObject().allWaitForRunning(100);
                    }
                } catch (Exception e) {

                    HAConnection.log.error(this.getServiceName() + " service has exception.", e);
                    break;
                }
            }

            HAConnection.this.haService.getWaitNotifyObject().removeFromWaitingThreadTable();

            // ...
            HAConnection.log.info(this.getServiceName() + " service end");
        }
    }
}

傳送資料

transferData方法的處理邏輯如下：

傳送訊息頭資料;
訊息頭資料傳送完畢之後，傳送訊息內容，前面知道從CommitLog中讀取的訊息內容放入到了selectMappedBufferResult，將selectMappedBufferResult的內容傳送給從節點;

public class HAConnection {
    class WriteSocketService extends ServiceThread {
        private boolean transferData() throws Exception {
            int writeSizeZeroTimes = 0;
            // 寫入訊息頭
            while (this.byteBufferHeader.hasRemaining()) {
                // 傳送訊息頭資料
                int writeSize = this.socketChannel.write(this.byteBufferHeader);
                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 header error < 0");
                }
            }

            if (null == this.selectMappedBufferResult) {
                return !this.byteBufferHeader.hasRemaining();
            }

            writeSizeZeroTimes = 0;

            // 訊息頭資料傳送完畢之後，傳送訊息內容
            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");
                    }
                }
            }
            // ...
            return result;
        }
    }
}

總結

主從同步流程

有新訊息寫入之後的同步流程

參考
丁威、周繼鋒《RocketMQ技術內幕》

RocketMQ版本：4.9.3

RocketMQ(九)：主從同步的實現
2020-12-27
MQ主從同步
RocketMQ主從同步
2019-03-27
MQ主從同步
rocketMq之雙主雙從同步模式搭建
2020-12-07
MQ模式
Mysql 主從同步原理簡析
2021-08-26
MySql主從同步
揭秘MySQL的主從同步實現方案
2022-12-01
MySql主從同步
透過原始碼分析RocketMQ主從複製原理
2023-03-02
原始碼MQ
Mysql 主從同步實戰
2017-04-10
MySql主從同步
DBMySQL主從同步原理及應用gcc
2022-03-01
MySql主從同步GC
Redis主從同步配置實踐
2018-11-29
Redis主從同步
Mysql主從同步(1) - 概念和原理介紹以及主從/主主模式部署記錄
2017-01-06
MySql主從同步模式
Mysql主從同步實戰(一)【知其然】
2019-03-29
MySql主從同步
資料庫讀寫分離，主從同步實現方法
2018-10-16
資料庫主從同步
MySQL怎麼實現主從同步和Django實現MySQL讀寫分離
2020-01-20
MySql主從同步Django
Redis主從同步
2022-04-23
Redis主從同步
mysql主從同步
2022-12-04
MySql主從同步
Rocketmq原理&最佳實踐
2018-08-05
MQ
RocketMQ雙主雙從叢集搭建
2020-09-24
MQ
linux下mysql主從複製，實現資料庫同步
2019-01-14
LinuxMySql資料庫
mysql主從選擇性同步某幾個庫實現方法
2017-05-12
MySql
Mysql實現主從複製（一主雙從）
2018-07-17
MySql
MySQL主從同步配置
2021-08-05
MySql主從同步
RocketMQ-環境部署-2主2從部署-同步雙寫-非同步刷盤-詳細步驟圖解
2020-12-09
MQ非同步圖解
RocketMQ的原理與實踐
2016-06-03
MQ
架構師必備：MySQL主從同步原理和應用
2021-10-08
架構MySql主從同步
MYSQL資料庫主從同步(一主一從)
2013-03-21
MySql資料庫主從同步
實戰與原理：如何基於RocketMQ實現分散式事務？
2024-01-29
MQ分散式
帶貨直播系統，透過主從同步實現讀寫分離
2021-07-02
主從同步
MySQL 資料主從同步
2020-04-10
MySql主從同步
redis主從同步機制
2020-12-03
Redis主從同步
MySql主從同步介紹
2022-08-17
MySql主從同步
mysql主從同步機制
2017-11-24
MySql主從同步
mysql master slave 主從同步
2014-04-08
MySqlAST主從同步
RocketMQ4.7.1雙主雙從叢集搭建
2020-10-30
MQ
MySQL主從分離實現
2020-07-25
MySql
redis 主從複製實現
2022-01-09
Redis
mysql實現主從複製
2018-11-20
MySql
MySQL主從同步（一主一從、一主多從、主從從）等結構的概述與配置
2018-11-13
MySql主從同步
MySQL-主從複製之同步主從資料
2018-10-14
MySql