常见的负载均衡算法

前言

　　前不久公司有个需求是任务需要按照权重分配来选择，当时就想到负载均衡算法里的加权随机法，因此对常见的负载均衡算法做个总结。

一、轮询（Round Robin）法

　　轮询就是将请求按顺序轮流地分配到后端服务器上，它均衡地对待后端每一台服务器，而不关心服务器实际的连接数和当前的系统负载。

        // serverWeightMap 表示服务器地址和权重的映射
        Map<String, Integer> serverWeightMap = new HashMap<>();
        serverWeightMap.put("192.168.1.100", 1);
        serverWeightMap.put("192.168.1.101", 1);
        // 权重为 4
        serverWeightMap.put("192.168.1.102", 4);
        serverWeightMap.put("192.168.1.103", 1);
        serverWeightMap.put("192.168.1.104", 1);
        // 权重为 3
        serverWeightMap.put("192.168.1.105", 3);
        serverWeightMap.put("192.168.1.106", 1);
        // 权重为 2
        serverWeightMap.put("192.168.1.107", 2);
        serverWeightMap.put("192.168.1.108", 1);
        serverWeightMap.put("192.168.1.109", 1);
        serverWeightMap.put("192.168.1.110", 1);

    public static String testRoundRobin() {
        // 重新创建一个 map，避免出现由于服务器上线和下线导致的并发问题
        Map<String, Integer> serverMap = new HashMap<>();
        serverMap.putAll(serverWeightMap);

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

        String server = null;

        Integer pos = 0;
        synchronized (pos) {
            if (pos >= keySet.size()) {
                pos = 0;
            }
            server = keyList.get(pos);
            pos++;
        }

        return server;
    }

　　由于 serverWeightMap 中的地址列表是动态的，随时可能有机器上线、下线或者宕机，因此为了避免可能出现的并发问题，如数组越界，通过新建方法内的局部变量 serverMap，先将域变量复制到线程本地，避免对多个线程修改。这样会引入新的问题，复制以后 serverWeightMap 的修改将无法反应给 serverMap，也就是说，在这一轮选择服务器的过程中，新增服务器或者下线服务器，负载均衡算法中将无法获知。新增比较好处理，而当服务器下线或者宕机时，服务消费者将有可能访问到不存在的地址。因此，在服务消费者的实现端需要考虑该问题，并且进行相应的容错处理，比如重新发起一次调用。
　　对于当前轮询的位置变量 pos，为了保证服务器选择的顺序性，需要在操作时对其加上 synchronized 锁，使得在同一时刻只有一个线程能够修改 pos 的值，否则当 pos 变量被并发修改时，则无法保证服务器选择的顺序性，甚至有可能导致 keyList 数组越界。
　　使用轮询策略的目的在于，希望做到请求转移的绝对平衡，但付出的性能代价也是相当大的。为了 pos 保证变量的互斥性，需要引入重量级的悲观锁 synchronized，将会导致该段轮询代码的并发吞吐量发生明显的下降。

二、随机（Random）法

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

    public static String testRandom() {
        // 重新创建一个 map，避免出现由于服务器上线和下线导致的并发问题
        Map<String, Integer> serverMap = new HashMap<>();
        serverMap.putAll(serverWeightMap);

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

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

        String server = keyList.get(randomPos);
        return server;
    }

　　跟前面类似，为了避免可能的并发问题，需要将 serverWeightMap 复制到 serverMap 中。通过 Random 的 nextInt 方法，取到在 0~keyList.size() 区间的一个随机值，从而从服务器列表中随机获取到一台服务器地址，进行返回。基于概率统计的理论，吞吐量越大，随机算法的效果越接近于轮询算法的效果。因此，基本可以替代轮询算法。

三、源地址哈希（Hash）法

　　源地址哈希的思想是获取客户端访问的 IP 地址值，通过哈希函数计算得到一个数值，用该数值对服务器列表的大小进行取模运算，得到的结果边是要访问的服务器的序号。采用哈希法进行负载均衡，同一 IP 地址的客户端，当后端服务器列表不变时，它每次都会映射到同一台后端服务器进行访问。

    public static String testConsumerHash(String remoteip) {
        // 重新创建一个 map，避免出现由于服务器上线和下线导致的并发问题
        Map<String, Integer> serverMap = new HashMap<>();
        serverMap.putAll(serverWeightMap);

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

        int hashCode = remoteip.hashCode();
        int serverListSize = keyList.size();
        int serverPos = hashCode % serverListSize;

        return keyList.get(serverPos);
    }

　　通过参数传入的客户端 remoteip 参数，取得它的哈希值，对服务器列表的大小取模，结果便是选用的服务器在服务器列表中的索引值。该算法保证了相同的客户端 IP 地址将会被“哈希”到同一台后端服务器，直到后端服务器列表变更。根据此特性可以在服务消费者与服务提供者之间建立有状态的 session 会话。

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

　　不同的后端服务器可能机器的配置和当前系统的负载并不相同，因此它们的抗压能力也不尽相同。给配置高、负载低的机器配置更高的权重，让其处理更多的请求，而低配置、负载高的机器，则给其分配较低的权重，降低其系统负载，加权轮询能很好地处理这一问题，并将请求顺序且按照权重分配到后端。

    public static String testWeightRoundRobin() {
        // 重新创建一个 map，避免出现由于服务器上线和下线导致的并发问题
        Map<String, Integer> serverMap = new HashMap<>();
        serverMap.putAll(serverWeightMap);

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

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

        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;

        Integer pos = 0;
        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<>();
        serverMap.putAll(serverWeightMap);

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

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

        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;
    }

    /**
     * 实现方法二
     */
    public static String testWeightRandom() {
        // 重新创建一个 map，避免出现由于服务器上线和下线导致的并发问题
        Map<String, Integer> serverMap = new HashMap<>();
        serverMap.putAll(serverWeightMap);

        // 计算权重和
        long weightSum = 0;
        for (String key : serverMap.keySet()) {
            weightSum += serverMap.get(key);
        }

        // 产生随机数
        long random = Math.round(Math.random() * weightSum);
        long weight = 0;
        for (String server : serverMap.keySet()) {
            weight += serverMap.get(server);
            if (weight >= random) {
                return server;
            }
        }

        return serverMap.keySet().iterator().next();
    }

　　我们费尽心思来实现服务消费者请求次数分配的均衡，我们知道这样做是没错的，可以为后端的多台服务器平均分配工作量，最大程度地提高服务器的利用率，但是，实际情况真的如此吗？在实际情况中，请求次数的均衡真的能代表负载的均衡吗？我们必须认真地思考这个问题。从算法实施的角度来看，以后端服务器的视角来观察系统的负载，而非请求发起方来观察。因此，我们得有其它的算法来实现可供选择，最小连接数法便属于此类算法。

六、最小连接数（Least Connections）法

　　最小连接数算法比较灵活和智能，由于后端服务器的配置不尽相同，对于请求的处理有快有慢，它正是根据后端服务器当前的连接情况，动态地选取其中当前积压连接数最小的一台服务器来处理当前请求，尽可能地提高后端服务器的利用效率，将负载合理地分流到每一台机器。由于最小连接数涉及服务器连接数的汇总和感知，设计与实现比较繁琐。