每個Java程式設計師都必須知道的四種負載均衡演算法

JAVA旭陽發表於2023-01-10
Java程式設計師負載演算法

前言

一般來說，我們在設計系統的時候，為了系統的高擴充套件性，會盡可能的建立無狀態的系統，這樣我們就可以採用叢集的方式部署，最終很方便的根據需要動態增減伺服器數量。但是，要使系統具有更好的可擴充套件性，除了無狀態設計之外，還要考慮採用什麼負載均衡演算法，本文就帶領大家認識以下常見的4種負載均衡演算法。

歡迎關注個人公眾號『JAVA旭陽』交流溝通

什麼是負載均衡

負載均衡是指多臺伺服器以對稱的方式組成一個伺服器叢集。每臺伺服器的地位相當（但不同的伺服器可能效能不同），可以獨立提供服務，無需其他伺服器的輔助。為了保證系統的可擴充套件性，需要有一種演算法能夠將系統負載平均分配給叢集中的每臺伺服器。這種演算法稱為負載均衡演算法。負責執行負載均衡演算法並平均分配請求的伺服器稱為負載均衡器。

隨機演算法

隨機演算法非常簡單，該演算法的核心是透過隨機函式隨機獲取一個伺服器進行訪問。假設我們現在有四臺伺服器，192.168.1.1~ 192.168.1.4, 該演算法用java實現大致如下：

public class RandomTest {

    private static final List<String> servers = Arrays.asList("192.168.1.1", "192.168.1.2", "192.168.1.3", "192.168.1.4");

    public static String getServer() {
        Random random = new Random();
        int index = random.nextInt(servers.size());
        return servers.get(index);
    }


    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            String server = getServer();
            System.out.println("select server: "+server);
        }
    }
}

當樣本較小時，演算法可能分佈不均勻，但根據機率論，樣本越大，負載會越均勻，而負載均衡演算法本來就是為應對高併發場景而設計的。該演算法的另一個缺點是所有機器都有相同的訪問機率, 如果伺服器效能不同，負載將不平衡。

輪詢演算法

Round-Robin輪詢演算法是另一種經典的負載均衡演算法。請求以迴圈的方式分發到叢集中的所有伺服器。同理，對於上述四臺伺服器，假設客戶端向叢集傳送10個請求，則請求分佈將如下圖所示：

在十個請求中，第一、第五和第九個請求將分配給192.168.1.1，第二、第六和第十個請求將分配給192.168.1.2，依此類推。我們可以看到round-robin演算法可以在叢集中均勻的分配請求。但是，該演算法具有與隨機演算法相同的缺點，如果伺服器效能不同，負載將不平衡，因此需要加權輪詢演算法。

加權輪詢演算法

Weighted Round-Robin加權輪詢演算法是在round-robin演算法的基礎上根據伺服器的效能分配權重。伺服器能支援的請求越多，權重就越高，分配的請求也就越多。對於同樣的10個請求，使用加權輪詢演算法的請求分佈會如下圖所示：

可以看到192.168.1.4權重最大，分配的請求數最多。看一下使用Java簡單實現的以下加權迴圈演算法。

public class RoundRobinTest {

    public class Node{
        private String ip;

        private Integer weight;

        private Integer currentWeight;

        public Node(String ip,Integer weight) {
            this.ip = ip;
            this.weight = weight;
            this.currentWeight = weight;
        }

        public String getIp() {
            return ip;
        }

        public void setIp(String ip) {
            this.ip = ip;
        }

        public Integer getWeight() {
            return weight;
        }

        public void setWeight(Integer weight) {
            this.weight = weight;
        }

        public Integer getCurrentWeight() {
            return currentWeight;
        }

        public void setCurrentWeight(Integer currentWeight) {
            this.currentWeight = currentWeight;
        }
    }

    List<Node> servers = Arrays.asList(
            new Node("192.168.1.1",1),
            new Node("192.168.1.2",2),
            new Node("192.168.1.3",3),
            new Node("192.168.1.4",4));
    private Integer totalWeight;

    public RoundRobinTest() {
        this.totalWeight = servers.stream()
                .mapToInt(Node::getWeight)
                .reduce((a,b)->a+b).getAsInt();
    }


    public String getServer() {
        Node node = servers.stream().max(Comparator.comparingInt(Node::getCurrentWeight)).get();
        node.setCurrentWeight(node.getCurrentWeight()-totalWeight);
        servers.forEach(server->server.setCurrentWeight(server.getCurrentWeight()+server.getWeight()));
        return node.getIp();
    }


    public static void main(String[] args) {
        RoundRobinTest roundRobinTest = new RoundRobinTest();
        for (int i = 0; i < 10; i++) {
            String server = roundRobinTest.getServer();
            System.out.println("select server: "+server);
        }
    }

該演算法的核心是的動態計算currentWeight。每個伺服器被選中後，currentWeight需要減去所有伺服器的權重之和，這樣可以避免權重高的伺服器一直被選中。權重高的伺服器有更多的分配請求，請求可以平均分配給所有伺服器。

雜湊演算法

雜湊演算法，顧名思義，就是利用雜湊表根據 計算出請求的路由hashcode%N。這裡hashcode代表雜湊值，N代表伺服器數量。該演算法的優點是實現起來非常簡單。具體實現如下：

rivate static final List<String> servers = Arrays.asList("192.168.1.1", "192.168.1.2", "192.168.1.3", "192.168.1.4");

    public static String getServer(String key) {
        int hash = key.hashCode();
        int index =  hash%servers.size();
        return servers.get(index);
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            String server = getServer(String.valueOf(i));
            System.out.println("select server: "+server);
        }
    }

雜湊演算法在很多快取分散式儲存系統中很常見，比如Memorycached和Redis，但是一般不會用到上面的雜湊演算法，而是最佳化後的一致性雜湊演算法。

總結

本文總結了負載均衡常見的4種演算法，我們可以發現nginx或者spring cloud中的ribbon都使用到了這樣的演算法思想，我們可以根據自己的業務場景選擇合適演算法。

歡迎關注個人公眾號『JAVA旭陽』交流溝通

相關文章