负载均衡算法

╰半橙微兮° 2021-06-24 13:58 426阅读 0赞

#### 1、轮询法 ####

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

private static Integer pos = 0;
        public String getHostByPoll(){
            List<String> hosts = Host.getHostList();
            String host;
            synchronized (pos){
                if(pos >= hosts.size()){
                    pos = 0;
                }
                host = hosts.get(pos++);
            }
            return host;
        }

#### 2、随机法 ####

*  通过系统的随机算法，根据后端服务器的列表大小值来随机选取其中的一台服务器进行访问。
 *  由概率统计理论可以得知，随着客户端调用服务端的次数增多，每台主机处理请求数越接近平均值。

public String getHostByRandom(){
            List<String> hosts = Host.getHostList();
            int randomNum = new Random().nextInt(hosts.size());
            System.out.println(randomNum);
            return hosts.get(randomNum);
        }

#### 3、加权轮询法 ####

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

private static Integer pos = 0;
    
        public String getHostByPollWeight(){
            Map<String,Integer> hosts = Host.getHostMap2();
            String host = null;
            synchronized (pos){
                for(Map.Entry<String,Integer> entry : hosts.entrySet()){
                    if(pos >= Host.totalWeight){
                        pos = 0;
                    }
                    if(pos < entry.getValue()){
                        host = entry.getKey();
                        pos++;
                        break;
                    }
                }
            }
            return host;
        }

#### 4、加权随机法 ####

*  不同的后端服务器可能机器的配置和当前系统的负载并不相同，因此它们的抗压能力也不相同。
 *  给配置高、负载低的机器配置更高的权重，让其处理更多的请；而配置低、负载高的机器，给其分配较低的权重，降低其系统负载。
 *  与加权轮询法不同的是，它是按照权重随机请求后端服务器。

public String getHostByRandomWeight(){
            Map<String ,Integer> hosts = Host.getHostMap();
            int randomNum = new Random().nextInt(Host.totalWeight);
            for(Map.Entry<String,Integer> entry : hosts.entrySet()){
                if(randomNum < entry.getValue()){
                    return entry.getKey();
                }else{
                    randomNum -= entry.getValue();
                }
            }
            return null;
        }

#### 5、源地址哈希法 ####

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

public String getHostByIpHash(int ipHash) {
            List<String> hosts = Host.getHostList();
            int pos = ipHash % hosts.size();
            return hosts.get(pos);
        }
    
        //模拟随机客户端的hash值
        public int getClientHash() {
            return new Random().nextInt(3);
        }

#### 6、最小连接数法 ####

*  由于后端服务器的配置不尽相同，对于请求的处理有快有慢。
 *  它正是根据后端服务器当前的连接情况，动态地选取其中当前积压连接数最小的一台服务器来处理当前请求，尽可能地提高后端服务器的利用效率，将负载合理地分流到每一台机器。

public Server getServerByLeastConnect(){
            List<Server> serverList = Host.getServerList();
            if(serverList == null || serverList.size() == 0){
                return null;
            }
            Server minConnectServer = serverList.get(0);
            for(int i = 1; i < serverList.size();i++){
                Server server = serverList.get(i);
                if(minConnectServer.getConnect() > server.getConnect()){
                    minConnectServer = server;
                }
            }
            minConnectServer.addConnect();
            return minConnectServer;
        }

**其中Host源码如下**：

public class Host {
    
    
        private static List<String> hostList;
        private static Map<String,Integer> hostMap;
        private static Map<String,Integer> hostMap2;
        public static int totalWeight;
    
        static {
            //初始化主机ip地址
            initHostList();
            initHostMap();
            initHostMap2();
        }
    
        public static void initHostList(){
            hostList = new ArrayList<>();
            hostList.add("192.168.0.1");
            hostList.add("192.168.0.2");
            hostList.add("192.168.0.3");
        }
    
        public static void initHostMap(){
            hostMap = new HashMap<>();
            //这里为了方便用A、B、C代表三个主机ip
            hostMap.put("A",5);
            hostMap.put("B",2);
            hostMap.put("C",3);
    
            Map<String ,Integer> hosts = Host.getHostMap();
            for(int v : hosts.values()){
                totalWeight += v;
            }
        }
    
        public static void initHostMap2(){
            hostMap2 = new HashMap<>();
            int weight = 0;
            for(Map.Entry<String,Integer> entry : hostMap.entrySet()){
                weight += entry.getValue();
                hostMap2.put(entry.getKey(),weight);
            }
    
        }
    
        public static List<String> getHostList(){
            return hostList;
        }
    
        public static Map<String,Integer> getHostMap(){
            return hostMap;
        }
    
        public static Map<String,Integer> getHostMap2(){
            return hostMap2;
        }
    }

文章所有源码地址都放到了Github上了，有兴趣的小伙伴可以下载下来看看哦。  
[GitHub][]源码地址：**[git@github.com:HelloWorld19930603/alien\_cat.git][git_github.com_HelloWorld19930603_alien_cat.git]**  
该算法源码对应目录：**alien\_cat/algorithm/src/main/java/com/aliencat/algorithm/lb**

[GitHub]: https://github.com/
[git_github.com_HelloWorld19930603_alien_cat.git]: https://github.com/HelloWorld19930603/alien_cat