Java負載均衡算法的作用是什么

這篇文章主要介紹“Java負載均衡算法的作用是什么”，在日常操作中，相信很多人在Java負載均衡算法的作用是什么問題上存在疑惑，小編查閱了各式資料，整理出簡單好用的操作方法，希望對大家解答”Java負載均衡算法的作用是什么”的疑惑有所幫助！接下來，請跟著小編一起來學習吧！

前言

負載均衡在Java領(lǐng)域中有著廣泛深入的應(yīng)用，不管是大名鼎鼎的nginx，還是微服務(wù)治理組件如dubbo，feign等，負載均衡的算法在其中都有著實際的使用

負載均衡的核心思想在于其底層的算法思想，比如大家熟知的算法有 輪詢，隨機，最小連接，加權(quán)輪詢等，在現(xiàn)實中不管怎么配置，都離不開其算法的核心原理，下面將結(jié)合實際代碼對常用的負載均衡算法做一些全面的總結(jié)。

輪詢算法

輪詢即排好隊，一個接一個的輪著來。從數(shù)據(jù)結(jié)構(gòu)上，有一個環(huán)狀的節(jié)點，節(jié)點上面布滿了服務(wù)器，服務(wù)器之間首尾相連，帶有順序性。當請求過來的時候，從某個節(jié)點的服務(wù)器開始響應(yīng)，那么下一次請求再來，就依次由后面的服務(wù)器響應(yīng)，由此繼續(xù)

按照這個描述，我們很容易聯(lián)想到，可以使用一個雙向(雙端)鏈表的數(shù)據(jù)結(jié)構(gòu)來模擬實現(xiàn)這個算法

1、定義一個server類，用于標識服務(wù)器中的鏈表節(jié)點

class Server {
    Server prev;
    Server next;
    String name;

    public Server(String name) {
        this.name = name;
    }
}

2、核心代碼

/**
 * 輪詢
 */
public class RData {
    private static Logger logger = LoggerFactory.getLogger(RData.class);
    //標識當前服務(wù)節(jié)點，每次請求過來時，返回的是current節(jié)點
    private Server current;

    public RData(String serverName) {
        logger.info("init servers : " + serverName);
        String[] names = serverName.split(",");
        for (int i = 0; i < names.length; i++) {
            Server server = new Server(names[i]);
            //當前為空，說明首次創(chuàng)建
            if (current == null) {
                //current就指向新創(chuàng)建server
                this.current = server;
                //同時，server的前后均指向自己
                current.prev = current;
                current.next = current;
            } else {
                //說明已經(jīng)存在機器了，則按照雙向鏈表的功能，進行節(jié)點添加
                addServer(names[i]);
            }
        }
    }

    //添加機器節(jié)點
    private void addServer(String serverName) {
        logger.info("add new server : " + serverName);
        Server server = new Server(serverName);
        Server next = this.current.next;
        //在當前節(jié)點后插入新節(jié)點
        this.current.next = server;
        server.prev = this.current;
        //由于是雙向鏈表，修改下一節(jié)點的prev指針
        server.next = next;
        next.prev = server;
    }
    //機器節(jié)點移除，修改節(jié)點的指向即可
    private void removeServer() {
        logger.info("remove current = " + current.name);
        this.current.prev.next = this.current.next;
        this.current.next.prev = this.current.prev;
        this.current = current.next;
    }

    //請求。由當前節(jié)點處理
    private void request() {
        logger.info("handle server is : " + this.current.name);
        this.current = current.next;
    }

    public static void main(String[] args) throws Exception {
        //初始化兩臺機器
        RData rr = new RData("192.168.10.0,192.168.10.1");
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    rr.request();
                }
            }
        }).start();
        //3s后，3號機器加入清單
        Thread.currentThread().sleep(2000);
        rr.addServer("192.168.10.3");

        //3s后，當前服務(wù)節(jié)點被移除
        Thread.currentThread().sleep(3000);
        rr.removeServer();
    }
}

結(jié)合注釋對代碼進行理解，這段代碼解釋開來就是考察對雙端鏈表的底層能力，操作鏈表結(jié)構(gòu)時，最重要的就是要搞清在節(jié)點的添加和移除時，理清節(jié)點的前后指向，然后再理解這段代碼時就沒有難度了，下面運行下程序

輪詢算法優(yōu)缺點小結(jié)

• 實現(xiàn)簡單，機器列表可自由加減，節(jié)點尋找時間復雜度為o(1)

• 無法針對節(jié)點做偏向性定制處理，節(jié)點處理能力強弱無法做區(qū)分對待，比如某些處理能力強配置高的服務(wù)器更希望承擔更多的請求這個就做不到

隨機算法

從可提供的服務(wù)器列表中隨機取一個提供響應(yīng)。

既然是隨機存取的場景，很容易想到使用數(shù)組可以更高效的通過下標完成隨機讀取，這個算法的模擬比較簡單，下面直接上代碼

/**
 * 隨機
 */
public class RandomMath {
    private static List<String> ips;
    public RandomMath(String nodeNames) {
        System.out.println("init servers : " + nodeNames);
        String[] nodes = nodeNames.split(",");
        //初始化服務(wù)器列表，長度取機器數(shù)
        ips = new ArrayList<>(nodes.length);
        for (String node : nodes) {
            ips.add(node);
        }
    }
    //請求處理
    public void request() {
        Random ra = new Random();
        int i = ra.nextInt(ips.size());
        System.out.println("the handle server is :" + ips.get(i));
    }
    //添加節(jié)點，注意，添加節(jié)點可能會造成內(nèi)部數(shù)組擴容
    void addnode(String nodeName) {
        System.out.println("add new node : " + nodeName);
        ips.add(nodeName);
    }

    //移除
    void remove(String nodeName) {
        System.out.println("remove node is: " + nodeName);
        ips.remove(nodeName);
    }

    public static void main(String[] args) throws Exception {
        RandomMath rd = new RandomMath("192.168.10.1,192.168.10.2,192.168.10.3");
        //使用一個線程，模擬不間斷的請求
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    rd.request();
                }
            }
        }).start();
        //間隔3秒之后，添加一臺新的機器
        Thread.currentThread().sleep(3000);
        rd.addnode("192.168.10.4");

        //3s后，當前服務(wù)節(jié)點被移除
        Thread.currentThread().sleep(3000);
        rd.remove("192.168.10.2");

    }
}

運行代碼觀察結(jié)果：

隨機算法小結(jié)

• 隨機算法簡單高效

• 適合一個服務(wù)器集群中，各個機器配置差不多的情況，和輪詢一樣，無法根據(jù)各個服務(wù)器本身的配置做一些定向的區(qū)分對待

加權(quán)隨機算法

在隨機選擇的基礎(chǔ)上，機器仍然是被隨機被篩選，但是做一組加權(quán)值，根據(jù)權(quán)值不同，機器列表中的各個機器被選中的概率不同，從這個角度理解，可認為隨機是一種等權(quán)值的特殊情況

設(shè)計思路依然相同，只是每個機器需要根據(jù)權(quán)值大小，生成不同數(shù)量的節(jié)點，節(jié)點排隊后，隨機獲取。這里的數(shù)據(jù)結(jié)構(gòu)主要涉及到隨 機的讀取，所以優(yōu)選為數(shù)組

/**
 * 加權(quán)隨機
 */
public class WeightRandom {
    ArrayList<String> list;

    public WeightRandom(String nodes) {
        String[] ns = nodes.split(",");
        list = new ArrayList<>();
        for (String n : ns) {
            String[] n1 = n.split(":");
            int weight = Integer.valueOf(n1[1]);
            for (int i = 0; i < weight; i++) {
                list.add(n1[0]);
            }
        }
    }

    public void request() {
        //下標，隨機數(shù)，注意因子
        int i = new Random().nextInt(list.size());
        System.out.println("the handle server is : " + list.get(i));
    }
    public static void main(String[] args) throws Exception{
        WeightRandom wr = new WeightRandom("192.168.10.1:2,192.168.10.2:1");
        for (int i = 0; i < 9; i++) {
            Thread.sleep(2000);
            wr.request();
        }
    }
}

我們不妨將10.1的權(quán)重值再調(diào)的大點，比如調(diào)為3，再次運行一下，這個效果就更明顯了

加權(quán)隨機算法小結(jié)

• 為隨機算法的升級和優(yōu)化

• 一定程度上解決了服務(wù)器節(jié)點偏向問題，可以通過指定權(quán)重來提升某個機器的偏向

加權(quán)輪詢算法

在前面的輪詢算法中我們看到，輪詢只是機械的旋轉(zhuǎn)不斷在雙向鏈表中進行移動，而加權(quán)輪詢則彌補了所有機器被一視同仁的缺點。在輪詢的基礎(chǔ)上，服務(wù)器初始化 時，各個機器攜帶一個權(quán)重值

加權(quán)輪詢的算法思想不是很好理解，下面我以一個圖進行說明：

加權(quán)輪詢算法的初衷是希望通過這樣一套算法保證整體的請求平滑性，從上圖中也可以發(fā)現(xiàn)，經(jīng)過幾輪的循環(huán)之后，由可以回到最初的結(jié)果，而且在某一個輪詢中，不同機器根據(jù)權(quán)重值的不同，請求被讀取的概率也會不同

實現(xiàn)思路和輪詢差不多，整體仍然是鏈表結(jié)構(gòu)，不同的是，每個具體的節(jié)點需加上權(quán)重值屬性

1、節(jié)點屬性類

class NodeServer {

    int weight;
    int currentWeight;
    String ip;
    public NodeServer(String ip, int weight) {
        this.ip = ip;
        this.weight = weight;
        this.currentWeight = 0;
    }

    @Override
    public String toString() {
        return String.valueOf(currentWeight);
    }
}

2、核心代碼

/**
 * 加權(quán)輪詢
 */
public class WeightRDD {
    //所有機器節(jié)點列表
    ArrayList<NodeServer> list;

    //總權(quán)重
    int total;

    //機器節(jié)點初始化 ， 格式：a#4,b#2,c#1，實際操作時可根據(jù)自己業(yè)務(wù)定制
    public WeightRDD(String nodes) {
        String[] ns = nodes.split(",");
        list = new ArrayList<>(ns.length);
        for (String n : ns) {
            String[] n1 = n.split("#");
            int weight = Integer.valueOf(n1[1]);
            list.add(new NodeServer(n1[0], weight));
            total += weight;
        }
    }
    public NodeServer getCurrent() {
        for (NodeServer node : list) {
            node.currentWeight += node.weight;
        }
        NodeServer current = list.get(0);
        int i = 0;
        //從列表中獲取當前的currentWeight最大的那個作為待響應(yīng)的節(jié)點
        for (NodeServer node : list) {
            if (node.currentWeight > i) {
                i = node.currentWeight;
                current = node;
            }
        }
        return current;
    }

    //請求，每次得到請求的節(jié)點之后，需要對當前的節(jié)點的currentWeight值減去 sumWeight
    public void request() {
        NodeServer node = this.getCurrent();
        System.out.print(list.toString() + "‐‐‐");
        System.out.print(node.ip + "‐‐‐");
        node.currentWeight -= total;
        System.out.println(list);
    }

    public static void main(String[] args) throws Exception {
        WeightRDD wrr = new WeightRDD("192.168.10.1#4,192.168.10.2#2,192.168.10.3#1");
        //7次執(zhí)行請求，觀察結(jié)果
        for (int i = 0; i < 7; i++) {
            Thread.currentThread().sleep(2000);
            wrr.request();
        }
    }
}

從打印輸出結(jié)果來看，也是符合預期效果的，具有更大權(quán)重的機器，在輪詢中被請求到的可能性更大

源地址hash算法

即對當前訪問的ip地址做一個hash值，相同的key將會被路由到同一臺機器去。常見于分布式集群環(huán)境下，用戶登錄 時的請求路由和會話保持

源地址hash算法可以有效解決在跨地域機器部署情況下請求響應(yīng)的問題，這一特點使得源地址hash算法具有某些特殊的應(yīng)用場景

該算法的核心邏輯是需要自定義一個能結(jié)合實際業(yè)務(wù)場景的hash算法，從而確保請求能夠盡可能達到源IP機器進行處理

源地址hash算法的實現(xiàn)比較簡單，下面直接上代碼

/**
 * 源地址請求hash
 */
public class SourceHash {
    private static List<String> ips;
    //節(jié)點初始化
    public SourceHash(String nodeNames) {
        System.out.println("init list : " + nodeNames);
        String[] nodes = nodeNames.split(",");
        ips = new ArrayList<>(nodes.length);
        for (String node : nodes) {
            ips.add(node);
        }
    }
    //添加節(jié)點
    void addnode(String nodeName) {
        System.out.println("add new node : " + nodeName);
        ips.add(nodeName);
    }
    //移除節(jié)點
    void remove(String nodeName) {
        System.out.println("remove one node : " + nodeName);
        ips.remove(nodeName);
    }
    //ip進行hash
    private int hash(String ip) {
        int last = Integer.valueOf(ip.substring(ip.lastIndexOf(".") + 1, ip.length()));
        return last % ips.size();
    }
    //請求模擬
    void request(String ip) {
        int i = hash(ip);
        System.out.println("req ip : " + ip + "‐‐>" + ips.get(i));
    }

    public static void main(String[] args) throws Exception {
        SourceHash hash = new SourceHash("192.168.10.1,192.168.10.2");
        for (int i = 1; i < 10; i++) {
            String ip = "192.168.1." + i;
            hash.request(ip);
        }

        Thread.sleep(3000);
        System.out.println();

        hash.addnode("192.168.10.3");
        for (int i = 1; i < 10; i++) {
            String ip = "192.168.1." + i;
            hash.request(ip);
        }
        Thread.sleep(3000);
        System.out.println();
        hash.remove("192.168.10.1");
        for (int i = 1; i < 10; i++) {
            String ip = "192.168.1." + i;
            hash.request(ip);
        }
    }
}

請關(guān)注核心的方法 hash()，我們模擬9個隨機請求的IP，下面運行下這段程序，觀察輸出結(jié)果

源地址hash算法小結(jié)

• 可以有效匹配同一個源IP從而定向到特定的機器處理

• 如果hash算法不夠合理，可能造成集群中某些機器壓力非常大

• 未能很好的解決新節(jié)點加入之后打破原來的請求平衡（一致性hash可解決）

最小請求數(shù)算法

即通過統(tǒng)計當前機器的請求連接數(shù)，選擇當前連接數(shù)最少的機器去響應(yīng)新請求。前面的各種算法是基于請求的維度，而最小 連接數(shù)則是站在機器的連接數(shù)量維度

從描述來看，實現(xiàn)這種算法需要定義一個鏈接表記錄機器的節(jié)點IP，和機器連接數(shù)量的計數(shù)器

而為了比較并選擇出最小的連接數(shù)的機器，內(nèi)部采用最小堆做排序處理，請求響應(yīng)時取堆頂節(jié)點即是 最小連接數(shù)（可以參考最小頂堆算法）

如圖所示，所有機器列表按照類二叉樹的結(jié)構(gòu)進行組裝，組裝的依據(jù)按照不同節(jié)點的訪問次數(shù)，某次請求過來時，選擇堆頂?shù)脑兀ù憫?yīng)的機器）返回，然后堆頂機器的請求數(shù)量加1，然后通過算法將這個堆頂?shù)脑叵鲁?，把請求?shù)量最小的元素上升為堆頂，以便下次響應(yīng)最新的請求

1、機器節(jié)點

該類記錄了節(jié)點的IP以及連接數(shù)

class Node {
    String name;
    AtomicInteger count = new AtomicInteger(0);
    public Node(String name) {
        this.name = name;
    }
    public void inc() {
        count.getAndIncrement();
    }
    public int get() {
        return count.get();
    }
    @Override
    public String toString() {
        return name + "=" + count;
    }
}

2、核心代碼

/**
 * 最小連接數(shù)算法
 */
public class LeastRequest {
    Node[] nodes;
    //節(jié)點初始化
    public LeastRequest(String ns) {
        String[] ns1 = ns.split(",");
        nodes = new Node[ns1.length + 1];
        for (int i = 0; i < ns1.length; i++) {
            nodes[i + 1] = new Node(ns1[i]);
        }
    }

    ///節(jié)點下沉，與左右子節(jié)點比對，選里面最小的交換
    //目的是始終保持最小堆的頂點元素值最小【結(jié)合圖理解】
    //ipNum:要下沉的頂點序號
    public void down(int ipNum) {
        //頂點序號遍歷，只要到1半即可，時間復雜度為O(log2n)
        while (ipNum << 1 < nodes.length) {
            int left = ipNum << 1;
            //右子，左+1即可
            int right = left + 1;
            int flag = ipNum;
            //標記，指向 本節(jié)點，左、右子節(jié)點里最小的，一開始取自己
            if (nodes[left].get() < nodes[ipNum].get()) {
                flag = left;
            }
            //判斷右子
            if (right < nodes.length && nodes[flag].get() > nodes[right].get()) {
                flag = right;
            }
            //兩者中最小的與本節(jié)點不相等，則交換
            if (flag != ipNum) {
                Node temp = nodes[ipNum];
                nodes[ipNum] = nodes[flag];
                nodes[flag] = temp;
                ipNum = flag;
            } else {
                //否則相等，堆排序完成，退出循環(huán)即可
                break;
            }
        }
    }
    //請求，直接取最小堆的堆頂元素就是連接數(shù)最少的機器
    public void request() {
        System.out.println("‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐");
        //取堆頂元素響應(yīng)請求
        Node node = nodes[1];
        System.out.println(node.name + " accept");
        //連接數(shù)加1
        node.inc();
        //排序前的堆
        System.out.println("ip list before:" + Arrays.toString(nodes));
        //堆頂下沉，通過算法將堆頂下層到合適的位置
        down(1);
        //排序后的堆
        System.out.println("ip list after:" + Arrays.toString(nodes));
    }

    public static void main(String[] args) {
        //假設(shè)有7臺機器
        LeastRequest lc = new LeastRequest("10.1,10.2,10.3,10.4,10.5,10.6,10.7");
        //模擬10個請求連接
        for (int i = 0; i < 10; i++) {
            lc.request();
        }
    }
}

請關(guān)注 down 方法，該方法是實現(xiàn)每次請求之后，將堆頂元素進行移動的關(guān)鍵實現(xiàn)，運行這段代碼，結(jié)合輸出結(jié)果進行理解

到此，關(guān)于“Java負載均衡算法的作用是什么”的學習就結(jié)束了，希望能夠解決大家的疑惑。理論與實踐的搭配能更好的幫助大家學習，快去試試吧！若想繼續(xù)學習更多相關(guān)知識，請繼續(xù)關(guān)注億速云網(wǎng)站，小編會繼續(xù)努力為大家?guī)砀鄬嵱玫奈恼拢?/p>