常见负载均衡算法

时间 2019-11-18

原文原文链接

1、概要

随着系统日益庞大、逻辑业务愈来愈复杂，系统架构由原来的单一系统到垂直系统，发展到如今的分布式系统。分布式系统中，能够作到公共业务模块的高可用，高容错性，高扩展性，然而，当系统愈来愈复杂时，须要考虑的东西天然也愈来愈多，要求也愈来愈高，好比服务路由、负载均衡等。此文将针对负载均衡算法进行讲解，不涉及具体的实现。java

2、负载均衡算法

在分布式系统中，多台服务器同时提供一个服务，并统一到服务配置中心进行管理，如图1-1。消费者经过查询服务配置中心，获取到服务到地址列表，须要选取其中一台来发起RPC远程调用。如何选择，则取决于具体的负载均衡算法，对应于不一样的场景，选择的负载均衡算法也不尽相同。负载均衡算法的种类有不少种，常见的负载均衡算法包括轮询法、随机法、源地址哈希法、加权轮询法、加权随机法、最小链接法等，应根据具体的使用场景选取对应的算法。算法

图1-1后端

一、轮询（Round Robin）法

轮询很容易实现，将请求按顺序轮流分配到后台服务器上，均衡的对待每一台服务器，而不关心服务器实际的链接数和当前的系统负载。数组

这里经过实例化一个serviceWeightMap的Map变量来服务器地址和权重的映射，以此来模拟轮询算法的实现，其中设置的权重值在之后的加权算法中会使用到，这里先不作过多介绍，该变量初始化以下：服务器

    private static Map<String, Integer> serviceWeightMap = new HashMap<String, Integer>();
    static {
        serviceWeightMap.put("192.168.1.100", 1);
        serviceWeightMap.put("192.168.1.101", 1);
　　　　 //权重为4
        serviceWeightMap.put("192.168.1.102", 4);
        serviceWeightMap.put("192.168.1.103", 1);
        serviceWeightMap.put("192.168.1.104", 1);
        //权重为3
        serviceWeightMap.put("192.168.1.105", 3);
        serviceWeightMap.put("192.168.1.106", 1);
        //权重为2
        serviceWeightMap.put("192.168.1.107", 2);
        serviceWeightMap.put("192.168.1.108", 1);
        serviceWeightMap.put("192.168.1.109", 1);
        serviceWeightMap.put("192.168.1.110", 1);
    }

经过该地址列表，实现的轮询算法的部分关键代码以下架构

    private static Integer pos = 0;
    
    public static String testRoundRobin() {
        
        // 从新建立一个map，避免出现因为服务器上线和下线致使的并发问题
        Map<String, Integer> serverMap = new HashMap<String, Integer>();
        serverMap.putAll(serviceWeightMap);
        
        //取得IP地址list
        Set<String> keySet = serverMap.keySet();
        ArrayList<String> keyList = new ArrayList<String>();
        keyList.addAll(keySet);
        
        String server = null;
        
        synchronized (pos) {
            if (pos > keySet.size()) {
                pos = 0;
            }
            
            server = keyList.get(pos);
            
            pos++;
        }
        
        return server;
    }

因为serviceWeightMap中的地址列表是动态的，随时可能由机器上线、下线或者宕机，所以，为了不可能出现的并发问题，好比数组越界，经过在方法内新建局部变量serverMap，先将域变量拷贝到线程本地，避免被其余线程修改。这样可能会引入新的问题，当被拷贝以后，serviceWeightMap的修改将没法被serverMap感知，也就是说，在这一轮的选择服务器中，新增服务器或者下线服务器，负载均衡算法中将没法获知。新增比较好处理，而当服务器下线或者宕机时，服务消费者将有可能访问不到不存在的地址。所以，在服务消费者服务端须要考虑该问题，而且进行相应的容错处理，好比从新发起一次调用。并发

对于当前轮询的位置变量pos，为了保证服务器选择的顺序性，须要对其在操做时加上synchronized锁，使得同一时刻只有一个线程可以修改pos的值，不然当pos变量被并发修改，将没法保证服务器选择的顺序性，甚至有可能致使keyList数组越界。负载均衡

使用轮询策略的目的是，但愿作到请求转移的绝对均衡，但付出的代价性能也是至关大的。为了保证pos变量的并发互斥，引入了重量级悲观锁synchronized，将会致使该轮询代码的并发吞吐量明显降低。dom

二、随机法

经过系统随机函数，根据后台服务器列表的大小值来随机选取其中一台进行访问。由几率几率统计理论能够得知，随着调用量的增大，其实际效果愈来愈接近于平均分配流量到后台的每一台服务器，也就是轮询法的效果。分布式

随机算法的部分关键代码以下：

    public static String testRandom() {

        // 从新建立一个map，避免出现因为服务器上线和下线致使的并发问题
        Map<String, Integer> serverMap = new HashMap<String, Integer>();
        serverMap.putAll(serviceWeightMap);

        //取得IP地址list
        Set<String> keySet = serverMap.keySet();
        ArrayList<String> keyList = new ArrayList<String>();
        keyList.addAll(keySet);

        Random random = new Random();
        int randomPos = random.nextInt(keyList.size());
        
        String server = keyList.get(randomPos);
        
        return server;
    }

跟前面相似，为了不并发的问题，须要将serviceWeightMap拷贝到serverMap中。经过Random的nextInt函数，取到0～keyList.size之间的随机值，从而从服务器列表中随机取到一台服务器的地址，进行返回。根据几率统计理论，吞吐量越大，随机算法的效果越接近于轮询算法的效果。

三、源地址哈希法

源地址哈希法的思想是根据服务消费者请求客户端的IP地址，经过哈希函数计算获得一个哈希值，将此哈希值和服务器列表的大小进行取模运算，获得的结果即是要访问的服务器地址的序号。采用源地址哈希法进行负载均衡，相同的IP客户端，若是服务器列表不变，将映射到同一个后台服务器进行访问。

源地址哈希法部分关键代码以下：

    public static String testConsumerHash(String remoteIp) {

        // 从新建立一个map，避免出现因为服务器上线和下线致使的并发问题
        Map<String, Integer> serverMap = new HashMap<String, Integer>();
        serverMap.putAll(serviceWeightMap);

        //取得IP地址list
        Set<String> keySet = serverMap.keySet();
        ArrayList<String> keyList = new ArrayList<String>();
        keyList.addAll(keySet);
        
        int hashCode = remoteIp.hashCode();
        int pos = hashCode % keyList.size();
        
        return keyList.get(pos);
    }

四、加权轮询（Weight Round Robin）法

不一样的后台服务器可能机器的配置和当前系统的负载并不相同，所以它们的抗压能力也不同。跟配置高、负载低的机器分配更高的权重，使其能处理更多的请求，而配置低、负载高的机器，则给其分配较低的权重，下降其系统负载，加权轮询很好的处理了这一问题，并将请求按照顺序且根据权重分配给后端。

加权轮询法部分关键代码以下：

    public static String testWeightRoundRobin() {

        // 从新建立一个map，避免出现因为服务器上线和下线致使的并发问题
        Map<String, Integer> serverMap = new HashMap<String, Integer>();
        serverMap.putAll(serviceWeightMap);

        //取得IP地址list
        Set<String> keySet = serverMap.keySet();
        Iterator<String> it = keySet.iterator();

        List<String> serverList = new ArrayList<String>();

        while (it.hasNext()) {
            String server = it.next();
            Integer weight = serverMap.get(server);
            for (int i=0; i<weight; i++) {
                serverList.add(server);
            }
        }

        String server = null;

        synchronized (pos) {
            if (pos > serverList.size()) {
                pos = 0;
            }
            
            server = serverList.get(pos);
            pos++;
        }
        
        return server;
    }

与轮询算法相似，只是在获取服务器地址以前增长了一段权重计算代码，根据权重的大小，将地址重复增长到服务器地址列表中，权重越大，该服务器每轮所得到的请求数量越多。

五、加权随机（Weight Random）法

加权随机法跟加权轮询法相似，根据后台服务器不一样的配置和负载状况，配置不一样的权重。不一样的是，它是按照权重来随机选取服务器的，而非顺序。

部分关键代码以下：

    public static String testWeightRandom() {
        // 从新建立一个map，避免出现因为服务器上线和下线致使的并发问题
        Map<String, Integer> serverMap = new HashMap<String, Integer>();
        serverMap.putAll(serviceWeightMap);

        //取得IP地址list
        Set<String> keySet = serverMap.keySet();
        List<String> serverList = new ArrayList<String>();
        Iterator<String> it = keySet.iterator();
        
        while (it.hasNext()) {
            String server = it.next();
            Integer weight = serverMap.get(server);
            for (int i=0; i<weight; i++) {
                serverList.add(server);
            }
        }

        Random random = new Random();
        int randomPos = random.nextInt(serverList.size());

        String server = serverList.get(randomPos);

        return server;
    }

六、最小链接数法

前面咱们费尽心思来实现服务消费者请求次数分配的均衡，咱们知道这样作是没错的，能够为后端的多台服务器平均分配工做量，最大程度地提升服务器的利用率，可是，实际上，请求次数的均衡并不表明负载的均衡。所以咱们须要介绍最小链接数法，最小链接数法比较灵活和智能，因为后台服务器的配置不尽相同，对请求的处理有快有慢，它正是根据后端服务器当前的链接状况，动态的选取其中当前积压链接数最少的一台服务器来处理当前请求，尽量的提升后台服务器利用率，将负载合理的分流到每一台服务器。