|
|
|
|
移动端

负载均衡的几种算法原理及代码实现

轮询算法: 将接收到的请求依次转发到后端服务器上,它均衡对待(一视同仁)所有服务器,而不关心当前服务器实际连接数及当前系统负载。

作者:tangyuanreward来源:GIS大数据开发|2018-07-27 08:39

技术沙龙 | 邀您于8月25日与国美/AWS/转转三位专家共同探讨小程序电商实战

轮询算法: 将接收到的请求依次转发到后端服务器上,它均衡对待(一视同仁)所有服务器,而不关心当前服务器实际连接数及当前系统负载。 这里实现一个简单的轮询系统:

  1. public class RoundRobin { 
  2.    static Integer  position = 0; 
  3.    public static List<String> initServerList() { 
  4.        List<String> servers = new ArrayList<>(); 
  5.        servers.add("192.168.10.00"); 
  6.        servers.add("192.168.10.01"); 
  7.        servers.add("192.168.10.02"); 
  8.        servers.add("192.168.10.03"); 
  9.        servers.add("192.168.10.04"); 
  10.        servers.add("192.168.10.05"); 
  11.        servers.add("192.168.10.06"); 
  12.        return servers; 
  13.    } 
  14.    public static String getServerUrl() { 
  15.        //新建立一个List赋值,避免服务器上下线导致的并发问题 
  16.        List<String> serverList = new ArrayList<>(); 
  17.        serverList.addAll(initServerList()); 
  18.        String server = null
  19.        synchronized (position){ 
  20.            if(position >= serverList.size()) { 
  21.                position = 0; 
  22.            } 
  23.            server = serverList.get(position); 
  24.            position ++; 
  25.        } 
  26.        return server; 
  27.    } 
  28.    public static void main(String[] args) { 
  29.        while (true){ 
  30.            System.out.println(getServerUrl()); 
  31.        } 
  32.    } 

在实际生产环境中,我们还得考虑诸多因素,比如:

新增服务器ip如何处理? 这个比较简单,直接添加到initServerList()即可。

出现服务宕机怎么办? 比如192.168.10.01 所在服务器挂掉了,请求被转发给它,就会报错。这时,需要服务的消费者考虑容错处理,在这种情况下,比如再发一次请求,那就会被转发到192.168.10.02 机器上,正常。 该方法最大缺点是引用了悲观锁 synchronized,影响系统的并发性能。

每台机器的配置不一样,有单核CPU,2G内存,有8核CPU,32G内存。这种情形下,使用上述轮询,那就不公平了,对弱配置机器,压力很大。 这个,我们可以引入

加权轮询: 每台服务器,给一个权重值,权值高的,多分配点儿请求,权值少的,少分配点儿请求,。 实现思路也很简单,根据权值,重新构建服务列表,然后再轮询。上个图示:

如下是代码实现:

  1. public class WeightRoundRobin { 
  2.    static Integer  position = 0; 
  3.    public static Map<String, Integer> initServicesMap() { 
  4.        Map<String, Integer> servicesMap = new HashMap<>(); 
  5.        servicesMap.put("192.168.10.00", 1); 
  6.        servicesMap.put("192.168.10.02", 3); 
  7.        servicesMap.put("192.168.10.03", 3); 
  8.        servicesMap.put("192.168.10.04", 5); 
  9.        servicesMap.put("192.168.10.05", 5); 
  10.        servicesMap.put("192.168.10.06", 5); 
  11.        return servicesMap; 
  12.    } 
  13.    public static String getServerUrl() { 
  14.        //新建立一个List赋值,避免服务器上下线导致的并发问题 
  15.        Map<String, Integer> initMap = new HashMap<>(); 
  16.        initMap = initServicesMap(); 
  17.        Set<String> servicesSet = new HashSet<>(); 
  18.        servicesSet.addAll(initMap.keySet()); 
  19.        Iterator<String> servicesIterator = servicesSet.iterator(); 
  20.        List<String> servicesList = new ArrayList<>(); 
  21.        while (servicesIterator.hasNext()) { 
  22.            String server = servicesIterator.next(); 
  23.            Integer weight = initMap.get(server); 
  24.            if(weight > 0) { 
  25.                for(int i=0; i<weight; i++) { 
  26.                    servicesList.add(server); 
  27.                } 
  28.            } 
  29.        } 
  30.        String server = null
  31.        synchronized (position){ 
  32.            if(position >= servicesList.size()) { 
  33.                position = 0; 
  34.            } 
  35.            server = servicesList.get(position); 
  36.            position ++; 
  37.        } 
  38.        return server; 
  39.    } 
  40.    public static void main(String[] args) { 
  41.        while (true){ 
  42.            System.out.println(getServerUrl()); 
  43.        } 
  44.    } 

随机算法:

顾名思义:现有N个服务器ip地址,请求来了后,随机转发到某个服务器上。从概率的角度来说,随着请求数的增多,最终每台服务器分配到的请求,近似于均等。这就比轮询算法少了个悲观锁,并发性能上,有了极大的提升。

实现也很简单:

如下:

  1. public class RandomDemo { 
  2.    public static List<String> initServerList() { 
  3.        List<String> servers = new ArrayList<>(); 
  4.        servers.add("192.168.10.00"); 
  5.        servers.add("192.168.10.01"); 
  6.        servers.add("192.168.10.02"); 
  7.        servers.add("192.168.10.03"); 
  8.        servers.add("192.168.10.04"); 
  9.        servers.add("192.168.10.05"); 
  10.        servers.add("192.168.10.06"); 
  11.        return servers; 
  12.    } 
  13.    public static String getServerUrl() { 
  14.        //新建立一个List赋值,避免服务器上下线导致的并发问题 
  15.        List<String> serverList = new ArrayList<>(); 
  16.        serverList.addAll(initServerList()); 
  17.        int position = new Random().nextInt(serverList.size()); 
  18.        return serverList.get(position); 
  19.    } 
  20.    public static void main(String[] args) { 
  21.        while (true) { 
  22.            System.out.println(getServerUrl()); 
  23.        } 
  24.    } 

但他也有与简单轮询算法一样的问题:

对于不同性能的服务器,依旧一视同仁,那其实是不公平的。低配置,应该少分点请求嘛。

这就有了

加权随机算法,其实现思想同 加权轮询算法一样,给不同配置的服务器,配置不同的权重值。代码实现也同加权轮询思路一样,构建出符合权重值的服务集合后,再进行随机选取,这里就不写了,留给大家自己去写吧。

源地址哈希(hashCode)法 : 根据客户端的请求ip,通过哈希计算,得到一个数值,随后与服务器列表个数,进行取模计算,得到该请求 访问服务器列表的序号。该方法,有个好处是,当服务器列表不变时,某个客户端,会始终访问某一个固定的服务器,这样就可以构建一个客户端--服务器之间,有状态的session。

代码实现:

  1. public class HashDemo {  
  2.    public static List<String> initServerList() {  
  3.        List<String> servers = new ArrayList<>();  
  4.        servers.add("192.168.10.00");  
  5.        servers.add("192.168.10.01");  
  6.        servers.add("192.168.10.02");  
  7.        servers.add("192.168.10.03");  
  8.        servers.add("192.168.10.04");  
  9.        servers.add("192.168.10.05");  
  10.        servers.add("192.168.10.06");  
  11.        return servers;  
  12.    }  
  13.    public static String getServerUrl() {  
  14.        //新建立一个List赋值,避免服务器上下线导致的并发问题  
  15.        List<String> serverList = new ArrayList<>();  
  16.        serverList.addAll(initServerList());  
  17.        int requestIpHashCode = "192.168.10.06.109".hashCode();  
  18.        int position = requestIpHashCode % serverList.size();  
  19.        return serverList.get(position);  
  20.    }  
  21.    public static void main(String[] args) {  
  22.        while (true) {  
  23.            System.out.println(getServerUrl());  
  24.        }  
  25.    }  
  26. }  

【编辑推荐】

  1. 如何才能全面实现软件定义数据中心(SDDC)?
  2. 【推荐】负载均衡很难?看完这篇全懂了
  3. Linux小技巧,如何实现免密码登录,为服务器运维节省时间
  4. 不用网关如何实现LoRa组网?
  5. 想要玩转实现负载均衡,你知道这些吗?
【责任编辑:武晓燕 TEL:(010)68476606】


点赞 0
分享:
大家都在看
猜你喜欢
24H热文
一周话题
本月最赞

读 书 +更多

网络渗透测试——保护网络安全的技术、工具和过程

网络和计算机安全问题已经成为政府、企业必须面对的现实问题。应对安全威胁的途径之一就是采用渗透测试的方法模拟黑客的攻击,找出网络和计...

订阅51CTO邮刊

点击这里查看样刊

订阅51CTO邮刊