分佈式選舉-Bully算法-2 代碼實現

Bully 算法實現

        設定集羣中有三個節點，通過Bully算法實現選主。節點之間的通信使用的是自我實現的Remoting組件，基於Netty開發，可以以同步，異步的方式發起通信。在後續《分佈式通信》系列的文章中，會向大家詳細分析Remoting組件。

 

分佈式選舉的項目名稱：justin-distribute-election

整體結構如圖：

 

節點和集羣類：

Node：表示集羣中的節點，包含節點ID，節點狀態，節點元數據等屬性。

// 節點ID
private final UUID nodeId = UUID.randomUUID();
// 節點狀態
private final AtomicReference<NodeStatus> status =
new AtomicReference<NodeStatus>(NodeStatus.UNKNOWN);
// 選舉週期，節點發起一次選舉，週期值加1。所有的節點必須在相同的週期內。
private final AtomicInteger epoch = new AtomicInteger(0);
private final String[] nodesAddress = PropertiesUtil.getNodesAddress();
// 處理節點請求消息的線程池
private final ExecutorService processorExecutor =
Executors.newFixedThreadPool(PropertiesUtil.getProcessorThreads());
private final Timer timer = new Timer("NodeMessage", true);
// 節點元數據，用於節點間的數據傳輸
private final Metadata metadata;
// 集羣，集羣中存儲所有節點的元數據，用於選舉。
private final Cluster cluster;

 

Cluster：表示集羣，包含所有節點的元數據，主節點，選舉週期等屬性。

// 選舉週期，與各節點一致
private final AtomicInteger epoch = new AtomicInteger(0);
// Key：節點的nodeId，Value：節點的元數據
private final ConcurrentMap<String, Metadata> nodes =
new ConcurrentHashMap<String, Metadata>();
// 選舉出的主節點
private AtomicReference<Metadata> leader =
new AtomicReference<Metadata>();

 

NodeStatus：表示節點的狀態，包含三種狀態，初始狀態(UNKNOWN)、存活狀態(ALIVE)、死亡狀態(DEAD)。

public enum NodeStatus {
    UNKNOWN,
    ALIVE,
    DEAD
}

 

節點啓動：

Node節點啓動時，在內部啓動了4個線程：

• server端線程，用於接收其他節點發送的消息；

• client端線程，用於向其他節點發送消息；

• 元數據同步線程，用於在集羣內同步各節點的元數據；

• 選舉線程，用於在集羣內選舉主節點；

public synchronized void start() {
    logger.info("Prepare start node[id: {}, address: {}:{}]", nodeId, host, port);
    if (status.get() != NodeStatus.ALIVE) {
        try {
            // 在集羣中加入本地節點
            cluster.addNode(nodeId, metadata);
           // 啓動Server，並註冊消息處理器
            server = new NettyRemotingServer(new NettyServerConfig(host, port));
            server.registerProcessor(MessageType.CLUSTER_SYNC, new ClusterSyncRequestProcessor(this), processorExecutor);
            server.registerProcessor(MessageType.ELECTION, new ElectionRequestProcessor(), processorExecutor);
            server.registerProcessor(MessageType.VICTORY, new VictoryRequestProcessor(this), processorExecutor);
            server.start();
           // 啓動Client
            client = new NettyRemotingClient(new NettyClientConfig());
            client.start();
            // 本地節點狀態設置爲ALIVE
            setStatus(NodeStatus.ALIVE);
            metadata.setNodeStatus(NodeStatus.ALIVE);
            // 週期線程，用於在集羣內同步各節點的元數據
            timer.scheduleAtFixedRate(new TimerTask() {
                @Override
                public void run() {
                    try {
                        Node.this.clusterSync(metadata);
                    }catch (Throwable e) {
                        logger.error("Cluster sync request failure: " + e.getMessage());
                    }
                }
            }, 2*1000, 10*1000);
            // 週期線程，用於選主
            timer.scheduleAtFixedRate(new TimerTask() {
                @Override
                public void run() {
                    try {
                        Node.this.electLeader();
                    }catch (Throwable e) {
                        logger.error("Elect leader failure: " + e.getMessage());
                    }
                }
            }, 5*1000, 5*1000);
        }catch (Exception e) {
            e.printStackTrace();
        }
    }else {
        logger.info("Node is alive " + this.toString());
    }
}

 

兩種週期線程的作用，如下圖：

 

Cluster Sync：

元數據同步線程，它的作用在於，在每個節點中維護一個集羣所有節點的元數據列表，用於選主。還有就是探測節點是否處於存活狀態。

private void clusterSync(Metadata metadata) throws Exception {
    for(String nodeAddress : nodesAddress) {
        if (!nodeAddress.equals(localAddr)) {
            // 向其他節點發送本地節點的元數據
            RemotingMessage response = client.invokeSync(nodeAddress, ClusterSyncMessage.getInstance().request(metadata), 3 * 1000);
            String peerNodeId = cluster.getNodeIdByaddr(nodeAddress);
            if (peerNodeId != null) {
                // 如果超過3次沒有響應，則設置節點狀態爲DEAD
                if (response == null) {
                    if (nodeDetectFailNums.containsKey(peerNodeId)) {
                        int failNums = nodeDetectFailNums.get(peerNodeId);
                        if (failNums >= 3) {
                            cluster.getNodes().get(peerNodeId).setNodeStatus(NodeStatus.DEAD);
                        } else {
                            nodeDetectFailNums.put(peerNodeId, ++failNums);
                        }
                    } else {
                        nodeDetectFailNums.put(peerNodeId, 1);
                    }
                } else {
                    nodeDetectFailNums.put(peerNodeId, 0);
                }
            }
        }
    }
}

 

元數據同步消息的處理類是：ClusterSyncRequestProcessor.class

public RemotingMessage processRequest(ChannelHandlerContext ctx, 
RemotingMessage request) throws Exception {
    Metadata peerNodeMetadata = ClusterSyncMessage.getInstance().getPeerNodeMetadata(request);
    logger.info("[" + node.getMetadata() + " ===> " + peerNodeMetadata + "] cluster sync!");
    // 將接收的節點元數據存入到本地元數據列表
    node.getCluster().addNode(peerNodeMetadata.getNodeId(), peerNodeMetadata);
    // 響應ALIVE消息
    byte[] res = "ALIVE".getBytes(Charset.forName("UTF-8"));
    request.setMessageBody(res);
    return request;
}

 

Elect Leader：

選舉線程，它的作用在於檢測集羣中是否有主節點或者主節點是否存活，否則發起選舉。

private void electLeader() throws Exception {
    logger.info("[" + metadata + "] cluster leader: " + cluster.getLeader());
    if (cluster.getNodes().size() > 1) {
        Metadata leader = cluster.getLeader();
        // 判斷集羣中是否有主節點或者主節點是否存活，沒有則發起選舉。
        if ((leader == null) || (leader.getNodeStatus() !=
            NodeStatus.ALIVE)) {
            logger.info("Starting election ...");
            epoch.getAndIncrement();
            metadata.setEpoch(epoch.get());
            // 獲取集羣中比自己ID大的所有節點
            List<Metadata> largerNodes = cluster.largerNodes(metadata);
            // 如果沒有則向其他節點發送Victory消息，宣佈爲主節點
            if (largerNodes.isEmpty()) {
                if (metadata.getNodeStatus() != NodeStatus.ALIVE) {
                    logger.warn("Node is not alive: " + metadata);
                }else {
                    cluster.getNodes().get(metadata.getNodeId().toString()).setEpoch(epoch.get());
                    cluster.setLeader(metadata);
                    List<Metadata> otherNodes = cluster.otherNodes(metadata);
                    for (Metadata otherNode : otherNodes) {
                        client.invokeOneway(otherNode.getNodeAddress(), VictoryMessage.getInstance().request(metadata), 3*1000);
                    }
                }
            }else {
                // 向比自己ID大的所有節點發送Election消息
                for (Metadata largerNode : largerNodes) {
                    RemotingMessage response = client.invokeSync(largerNode.getNodeAddress(), ElectionMessage.getInstance().request(metadata), 3*1000);
                    String res = new String(response.getMessageBody(), Charset.forName("UTF-8"));
                    logger.info("Election response: " + res);
                }
            }
        }
    }
}

 

Election消息的處理類是：ElectionRequestProcessor.class

public RemotingMessage processRequest(ChannelHandlerContext ctx, RemotingMessage request) throws Exception {
    Metadata peerNodeMetadata = ElectionMessage.getInstance().getPeerNodeMetadata(request);
    logger.info("[ ===> " + peerNodeMetadata + "] election!");
    // 響應ALIVE消息
    byte[] res = "ALIVE".getBytes(Charset.forName("UTF-8"));
    request.setMessageBody(res);
    return request;
}

 

Victory消息的處理類是：VictoryRequestProcessor.class

public RemotingMessage processRequest(ChannelHandlerContext ctx, RemotingMessage request) throws Exception {
    Metadata peerNodeMetadata = VictoryMessage.getInstance().getPeerNodeMetadata(request);
    logger.info("[" + node.getMetadata() + " ===> " + peerNodeMetadata + "] victory!");
    // 更新選舉週期
    node.setEpoch(peerNodeMetadata.getEpoch());
    node.getCluster().setEpoch(peerNodeMetadata.getEpoch());
    // 在集羣中設置主節點
    node.getCluster().setLeader(peerNodeMetadata);
    return null;
}

至此，根據Bully算法的選主代碼實現完成。

 

下一篇文章《分佈式選舉-Raft算法-1 Leader選舉 原理》講解典型的多數派投票選舉算法Raft的選舉原理。

---

獲取Bully算法的實現代碼，請關注公衆號，後臺回覆“ Bully ”獲取源碼。