面向服务的体系架构(SOA)——负载均衡

负载均衡的几个常用算法

服务消费者从服务配置中心获取到服务器的列表后，需要选取其中的一台发起RPC调用。如何选择取决于具体的负载均衡算法，不同的场景需要选择不同的算法。常见的负载均衡算法包括：轮询(Round Robin)法、随机(Random)法、源地址哈希(Hash)法、加权轮询(Weight Round Robin)法、加权随机(Weight Random)法、最小连接(Least Connections)法。

下面简单介绍一下各个算法：

1、轮询(Round Robin)法

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

下面先准备一个serverWeightMap的Map变量来表示服务器地址和权重的映射，以此来模拟轮询算法的实现过程：变量初始化如下：

serverWeightMap = new HashMap<String, Integer>();
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);
serverWeightMap.put("192.168.1.107", 1);

//权重为2
serverWeightMap.put("192.168.1.108", 2);
serverWeightMap.put("192.168.1.109", 1);

其中IP地址192.168.1.2的权重为4，192.168.1.105的权重为3，192.168.1.108的权重为2。通过该地址列表，实现的轮询算法的部分关键代码如下：

//轮询
public static String testRoundRobin() {

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

    //取得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;

} 

由于serverWeightMap中的地址列表是动态的，随时可能有机器上线、下线或者宕机，因此，为了避免可能出现的并发问题，如数组越界通过新建方法内的局部变量serverMap，先将域变量复制到纯种本地，以避免被多个线程修改。这样可能会引入新的问题，复制以后 serverWeightMap的自发将无法反映给serverMap，即在这一轮选择服务器的过程中，新增服务器或者下线服务器，负载均衡算法中将无法获知。新增比较好处理，而当服务器下线或者宕机时，服务消费者将有可能访问到不存在的地址。因此，在服务消费者的实现端需要考虑该 问题，并且进行相应的容错处理，比如重新发起一次调用。

对于当前轮询的位置变量pos，为了保证服务器选择的顺序性，需要在操作时对其加上synchronized锁，使得在同一时刻只有一个线程能够修改pos的值，否则当pos变量被并发修改时，则无法保证服务器选择的顺序性，甚至有可能导致keyList数组越界。

使用轮询策略的目的在于，希望做到请求转移的绝对均衡，但付出的性能代价也是相当大的。为了保证pos变量修改后的互斥性，需要引入重量级的悲观锁synchronized，将会导致该 段轮询代码的并发吞吐量发生明显的下降。

2、随机(Random)法

随机法——通过系统随机函数，根据后端服务器列表的大小值来随机选择其中一台进行访问。

由概率统计理论可以得知，随着调用量的增大，其实际效果越来越接近于平均分配流量到第一台后端服务器，即轮询的效果。

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

//随机
public static String testRondam() {

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

    //取得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;

}

通过Random的nextInt方法，取到在0~keyList.size()区间的一个随机值，从而在服务器列表中随机获取到一台服务器地址进行返回。根据概率统计理论，吞吐量越大，随机算法的效果越接近于轮询算法的效果。

3、源地址哈希(Hash)法

源地址哈希法——获取客户端访问的IP地址值，通过哈希函数计算得到一个数值，用该数值对服务器列表的大小进行进行取模运算，得到 的结果便是要访问的服务器的序号。

采用哈希法进行负载均衡，同一IP地址的客户端，当后端服务器列表不变时，它每次都会被映射到同一台后端服务器进行访问。

源地址哈希算法实现的部分关键代码：

//源地址哈希法
public static String testConsumerHash(String remoteIP){

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

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

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

    return keyList.get(serverPos);

}

通过传入客户端remoteIP参数，取得它的哈希值，对服务器列表的大小进行取模，结果就是选用的服务器在服务器列表中的索引值。该算法保证了相同的客户端IP地址会被映射到同一台后端服务器，直到服务器列表发生改变。根据此重金属可以在服务消费者与服务提供者之间建立有状态的session对话。

4、加权轮询(Weight Round Robin)法

不同的后端服务器可能机器的配置和当前系统的负载并不相同，因此它们的抗压能力也不尽相同。

加权轮询法——给配置高、负载低的机器配置更高权重，让其处理更多的请求；而配置低、负载高的机器分配较低的权重，降低其系统负载。

加权轮询能很好地处理这一问题，并将请求顺序按照权重分配到后端。

加权轮询算法实现的部分关键代码：

//加权轮询
public static String testWeightRoundRobin() {

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

    //取得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;

}

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

5、加权随机(Weight Random)法

加权随机法——根据后端服务器不同的配置和负载情况，配置不同的权重，按照权重来随机选取服务器。

加权随机算法实现的部分关键代码：

//加权随机
public static String testWeightRandom() {

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

    //取得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);
        }       
    }

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

    return server;

}

前面这些算法都是为了实现服务消费者请求次数分配的均衡，这样做并没有错，可以为后端服务器平均分配工作量，最大程度地提高服务器的利用率。然而，实际情况真的如此吗？在实际情况中，请求次数的均衡真的能代表负载的均衡吗？这个问题值得我们认真思考。

从算法实施的角度来看，以后端服务器的视角来观察系统的负载，而非请求发起方来观察。

因此，我们得有其他的算法来实现可供选择，最小连接数法便属于这类算法。

6、最小连接数(Least Connections)法

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

Standing on shoulders of Giants.
（持续更新，敬请关注）