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

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

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

public class RoundRobin { 
   static Integer  position = 0; 
   public static List<String> initServerList() { 
       List<String> servers = new ArrayList<>(); 
       servers.add("192.168.10.00"); 
       servers.add("192.168.10.01"); 
       servers.add("192.168.10.02"); 
       servers.add("192.168.10.03"); 
       servers.add("192.168.10.04"); 
       servers.add("192.168.10.05"); 
       servers.add("192.168.10.06"); 
       return servers; 
   } 
   public static String getServerUrl() { 
       //新建立一个List赋值,避免服务器上下线导致的并发问题 
       List<String> serverList = new ArrayList<>(); 
       serverList.addAll(initServerList()); 
       String server = null
       synchronized (position){ 
           if(position >= serverList.size()) { 
               position = 0; 
           } 
           server = serverList.get(position); 
           position ++; 
       } 
       return server; 
   } 
   public static void main(String[] args) { 
       while (true){ 
           System.out.println(getServerUrl()); 
       } 
   } 

  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  • 25.
  • 26.
  • 27.
  • 28.
  • 29.
  • 30.
  • 31.
  • 32.
  • 33.

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

[[238078]]

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

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

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

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

如下是代码实现:

public class WeightRoundRobin { 
   static Integer  position = 0; 
   public static Map<String, Integer> initServicesMap() { 
       Map<String, Integer> servicesMap = new HashMap<>(); 
       servicesMap.put("192.168.10.00", 1); 
       servicesMap.put("192.168.10.02", 3); 
       servicesMap.put("192.168.10.03", 3); 
       servicesMap.put("192.168.10.04", 5); 
       servicesMap.put("192.168.10.05", 5); 
       servicesMap.put("192.168.10.06", 5); 
       return servicesMap; 
   } 
   public static String getServerUrl() { 
       //新建立一个List赋值,避免服务器上下线导致的并发问题 
       Map<String, Integer> initMap = new HashMap<>(); 
       initMap = initServicesMap(); 
       Set<String> servicesSet = new HashSet<>(); 
       servicesSet.addAll(initMap.keySet()); 
       Iterator<String> servicesIterator = servicesSet.iterator(); 
       List<String> servicesList = new ArrayList<>(); 
       while (servicesIterator.hasNext()) { 
           String server = servicesIterator.next(); 
           Integer weight = initMap.get(server); 
           if(weight > 0) { 
               for(int i=0; i<weight; i++) { 
                   servicesList.add(server); 
               } 
           } 
       } 
       String server = null
       synchronized (position){ 
           if(position >= servicesList.size()) { 
               position = 0; 
           } 
           server = servicesList.get(position); 
           position ++; 
       } 
       return server; 
   } 
   public static void main(String[] args) { 
       while (true){ 
           System.out.println(getServerUrl()); 
       } 
   } 

  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  • 25.
  • 26.
  • 27.
  • 28.
  • 29.
  • 30.
  • 31.
  • 32.
  • 33.
  • 34.
  • 35.
  • 36.
  • 37.
  • 38.
  • 39.
  • 40.
  • 41.
  • 42.
  • 43.
  • 44.
  • 45.

随机算法:

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

实现也很简单:

如下:

public class RandomDemo { 
   public static List<String> initServerList() { 
       List<String> servers = new ArrayList<>(); 
       servers.add("192.168.10.00"); 
       servers.add("192.168.10.01"); 
       servers.add("192.168.10.02"); 
       servers.add("192.168.10.03"); 
       servers.add("192.168.10.04"); 
       servers.add("192.168.10.05"); 
       servers.add("192.168.10.06"); 
       return servers; 
   } 
   public static String getServerUrl() { 
       //新建立一个List赋值,避免服务器上下线导致的并发问题 
       List<String> serverList = new ArrayList<>(); 
       serverList.addAll(initServerList()); 
       int position = new Random().nextInt(serverList.size()); 
       return serverList.get(position); 
   } 
   public static void main(String[] args) { 
       while (true) { 
           System.out.println(getServerUrl()); 
       } 
   } 

  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  • 25.

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

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

这就有了

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

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

代码实现:

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

 【编辑推荐】

责任编辑:武晓燕 来源: GIS大数据开发
相关推荐

2019-04-12 09:00:01

负载均衡Java服务器

2018-04-10 10:49:17

负载均衡算法服务器

2010-04-21 15:06:37

负载均衡算法

2017-02-09 16:16:24

Java负载均衡算法

2019-12-26 09:13:00

算法硬件软件

2015-09-25 09:56:37

负载均衡

2010-04-26 15:04:08

负载均衡器

2024-06-18 08:14:21

2010-05-06 12:18:34

IP负载均衡

2020-04-27 10:00:53

负载均衡互联网架构

2021-10-21 10:02:37

Java开发代码

2021-10-10 13:31:14

Java负载均衡算法

2023-02-07 06:42:24

Pulsar负载均衡

2010-05-04 16:10:51

负载均衡算法

2019-04-29 11:00:14

架构负载均衡互联网

2023-03-03 08:26:32

负载均衡算法服务

2019-08-26 08:36:09

负载均衡高可用Nginx

2024-03-28 13:10:20

负载均衡LVSHaproxy

2010-11-19 12:53:53

梭子鱼负载均衡

2010-04-22 17:53:36

Apache负载均衡
点赞
收藏

51CTO技术栈公众号