Java代码实现负载均衡五种算法

灰太狼 2023-02-16 14:30 129阅读 0赞

### 文章目录 ###

*  概况
 *   *  轮询法
     *  加权轮询法
     *  随机法
     *  加权随机法
     *  IP哈希法

参考： [Java代码实现负载均衡五种算法][Java]

# 概况 #

![Center][]

## 轮询法 ##

轮询算法按顺序把每个新的连接请求分配给下一个服务器，最终把所有请求平分给所有的服务器。

*  优点：绝对公平
 *  缺点：无法根据服务器性能去分配，无法合理利用服务器资源。

@Configuration
    @Slf4j
    public class RoundMethod {
        
    
        // 指向该服务的server的指针
        AtomicInteger index = new AtomicInteger(0);
    
        public String roundMethod(Map<String,Integer> serverMap){
        
            // 服务名
            Set<String> set = serverMap.keySet();
            List<String> list = new ArrayList<>();
            list.addAll(set);
            String serverName = "";
            if(index.get() == list.size()){
        
                index.set(0);
            }
            int pos = index.getAndIncrement();
            serverName = list.get(pos);
            return serverName;
        }
    
        public static void main(String[] args) {
        
            RoundMethod roundMethod = new RoundMethod();
            //模拟eureka注册中心的服务信息列表，key：IP，value：权重
            Map<String,Integer> map = new ConcurrentHashMap<>();
            map.put("192.168.13.1",1);
            map.put("192.168.13.2",1);
            map.put("192.168.13.3",1);
            for(int i = 0;i < 10;i++){
        
                String s = roundMethod.roundMethod(map);
                log.info("------------>>>>>>" + s);
            }
        }
    }

## 加权轮询法 ##

该算法中，每个机器接受的连接数量是按权重比例分配的。这是对普通轮询算法的改进，比如你可以设定：第三台机器的处理能力是第一台机器的两倍，那么负载均衡器会把两倍的连接数量分配给第3台机器。

@Slf4j
    @Configuration
    public class RoundWeightMethod {
        
    
        // 指向该服务的server的指针
        AtomicInteger index = new AtomicInteger(0);
    
        public String roundWeightMethod(Map<String,Integer> serverMap){
        
            // 服务名
            Set<String> set = serverMap.keySet();
            // 放所有的server。可重复，根据权重放
            List<String> list = new ArrayList<>();
            Iterator<String> iterator = set.iterator();
            while(iterator.hasNext()){
        
                String serverName = iterator.next();
                // 取出权重
                int weight = serverMap.get(serverName);
                // 放入权重个serverName到list中
                for(int i = 0;i < weight;i++){
        
                    list.add(serverName);
                }
            }
            String res = "";
            if(index.get() == list.size()){
        
                index.set(0);
            }
            int pos = index.getAndIncrement();
            res = list.get(pos);
            return res;
        }
    
        public static void main(String[] args) {
        
            RoundWeightMethod roundMethod = new RoundWeightMethod();
            //模拟eureka注册中心的服务信息列表，key：IP，value：权重
            Map<String,Integer> map = new ConcurrentHashMap<>();
            map.put("192.168.13.1",1);
            map.put("192.168.13.2",1);
            map.put("192.168.13.3",1);
            for(int i = 0;i < 10;i++){
        
                String s = roundMethod.roundWeightMethod(map);
                log.info("------------>>>>>>" + s);
            }
        }
    }

## 随机法 ##

负载均衡方法随机的把负载分配到各个可用的服务器上，通过随机数生成算法选取一个服务器

@Slf4j
    @Configuration
    public class RandomMethod {
        
    
        // 指向该服务的server的指针
        AtomicInteger index = new AtomicInteger(0);
    
        public String randomMethod(Map<String,Integer> serverMap){
        
            // 服务名
            Set<String> set = serverMap.keySet();
            List<String> list = new ArrayList<>();
            list.addAll(set);
            String serverName = "";
            Random random = new Random();
            int pos = random.nextInt(list.size());
            serverName = list.get(pos);
            return serverName;
        }
    
        public static void main(String[] args) {
        
            RandomMethod roundMethod = new RandomMethod();
            //模拟eureka注册中心的服务信息列表，key：IP，value：权重
            Map<String,Integer> map = new ConcurrentHashMap<>();
            map.put("192.168.13.1",1);
            map.put("192.168.13.2",1);
            map.put("192.168.13.3",1);
            for(int i = 0;i < 10;i++){
        
                String s = roundMethod.randomMethod(map);
                log.info("------------>>>>>>" + s);
            }
        }
    }

## 加权随机法 ##

在随机法的基础上加上权重，权重大的被使用的概率也会增大

@Slf4j
    @Configuration
    public class RandomWeightMethod {
        
    
        // 指向该服务的server的指针
        AtomicInteger index = new AtomicInteger(0);
    
        public String randomWeightMethod(Map<String,Integer> serverMap){
        
            // 服务名
            Set<String> set = serverMap.keySet();
            // 放所有的server。可重复，根据权重放
            List<String> list = new ArrayList<>();
            Iterator<String> iterator = set.iterator();
            while(iterator.hasNext()){
        
                String serverName = iterator.next();
                // 取出权重
                int weight = serverMap.get(serverName);
                // 放入权重个serverName到list中
                for(int i = 0;i < weight;i++){
        
                    list.add(serverName);
                }
            }
            String res = "";
            Random random = new Random();
            int pos = random.nextInt(list.size());
            res = list.get(pos);
            return res;
        }
    
        public static void main(String[] args) {
        
            RandomWeightMethod roundMethod = new RandomWeightMethod();
            //模拟eureka注册中心的服务信息列表，key：IP，value：权重
            Map<String,Integer> map = new ConcurrentHashMap<>();
            map.put("192.168.13.1",1);
            map.put("192.168.13.2",2);
            map.put("192.168.13.3",3);
            for(int i = 0;i < 10;i++){
        
                String s = roundMethod.randomWeightMethod(map);
                log.info("------------>>>>>>" + s);
            }
        }
    }

## IP哈希法 ##

根据客户端的IP进行哈希算法求出请求的机器

@Configuration
    public class IpHashMethod {
        
    
    
        //    1.定义map, key-ip,value-weight
        static Map<String,Integer> ipMap=new HashMap<>();
        static {
        
            ipMap.put("192.168.13.1",1);
            ipMap.put("192.168.13.2",2);
            ipMap.put("192.168.13.3",4);
        }
        public String ipHash(String clientIP){
        
            Map<String,Integer> ipServerMap=new ConcurrentHashMap<>();
            ipServerMap.putAll(ipMap);
            //    2.取出来key,放到set中
            Set<String> ipset=ipServerMap.keySet();
            //    3.set放到list，要循环list取出
            ArrayList<String> iplist=new ArrayList<String>();
            iplist.addAll(ipset);
            //对ip的hashcode值取余数，每次都一样的
            int hashCode=clientIP.hashCode();
            int serverListsize=iplist.size();
            int pos=hashCode%serverListsize;
            return iplist.get(pos);
        }
    
        public static void main(String[] args) {
        
            IpHashMethod iphash=new IpHashMethod();
            String servername= iphash.ipHash("192.168.21.2");
            System.out.println(servername);
        }
    }

[Java]: https://blog.csdn.net/zhou2s_101216/article/details/78358354
[Center]: https://img-blog.csdn.net/20171026203739977?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvemhvdTJzXzEwMTIxNg==/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center