几种常见的负载均衡算法实现

原创 2017年07月09日 19:56:59

常见的负载均衡算法包括轮询法、随机法、源地址哈希法、加权轮询法、加权随机法、最小连接法等。具体实现如下:

package algorithm;

import java.util.*;

public class LoadBalancing {

    static Map<String,Integer> serverWeightMap = new HashMap<String,Integer>();
    static Integer pos = 0;
    static{
        serverWeightMap.put("192.168.1.100",1);
        serverWeightMap.put("192.168.1.101",1);
        serverWeightMap.put("192.168.1.102",4);
        serverWeightMap.put("192.168.1.103",1);
        serverWeightMap.put("192.168.1.104",1);
        serverWeightMap.put("192.168.1.105",3);
        serverWeightMap.put("192.168.1.106",1);
        serverWeightMap.put("192.168.1.107",2);
        serverWeightMap.put("192.168.1.108",1);
        serverWeightMap.put("192.168.1.109",1);
        serverWeightMap.put("192.168.1.110",3);
    }

    //轮询
    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 = new Integer(0);
            }
            server = keyList.get(pos);
            pos++;
        }
        return server;

    }

    //随机
    public static String testRandom(){
        //重新创建一个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;
    }

    //源地址哈希(hash)法
    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);
    }

    //加权轮询
    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 = new Integer(0);
            }
            server = serverList.get(pos);
            pos++;
        }
        return server;
    }

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


        //取得ip地址list
        Set<String> keySet = serverMap.keySet();
        ArrayList<String> serverList = new ArrayList<String>();

        Iterator<String> iterator = keySet.iterator();
        while(iterator.hasNext()){
            String server = iterator.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;
    }
}
版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

常见的几种负载均衡详解

  • 2014年10月15日 09:49
  • 302KB
  • 下载

几种典型的负载均衡算法

  • 2010年10月29日 13:58
  • 18KB
  • 下载

几种简单的负载均衡算法及其Java代码实现

http://www.importnew.com/22821.html?utm_source=tuicool&utm_medium=referral 什么是负载均衡 负载均衡,...

几种简单的负载均衡算法及其 Java 代码实现

什么是负载均衡 负载均衡,英文名称为Load Balance,指由多台服务器以对称的方式组成一个服务器集合,每台服务器都具有等价的地位,都可以单独对外提供服务而无须其他服务器的辅助。通过某种负载...

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

轮询: 1 package class2.zookeeper.loadbalance; 2 3 import java.util.ArrayList; 4 import java....

几种简单的负载均衡算法及其Java代码实现

什么是负载均衡 负载均衡,英文名称为Load Balance,指由多台服务器以对称的方式组成一个服务器集合,每台服务器都具有等价的地位,都可以单独对外提供服务而无须其他服务器的辅助。通过某种负载...

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

轮询 package class2.zookeeper.loadbalance; import java.util.ArrayList; import java.util.HashMap;...

7. 常见的简单负载均衡算法以及Java实现

读完本文你将知道: 1. 什么是负载均衡? 2. 负载均衡的几种简单实现: (1) 轮询法(Round Robin) (2)随机法(Random) (3)源地址Hash法...

常见的负载均衡算法及其代码实现

什么是负载均衡负载均衡,英文名称为Load Balance,指由多台服务器以对称的方式组成一个服务器集合,每台服务器都具有等价的地位,都可以单独对外提供服务而无须其他服务器的辅助。通过某种负载分担技术...
  • FX_SKY
  • FX_SKY
  • 2016年12月29日 10:35
  • 836

常见的简单负载均衡算法以及Java实现

读完本文你将知道:  1. 什么是负载均衡?  2. 负载均衡的几种简单实现:  (1) 轮询法(Round Robin)  (2)随机法(Random)  (3)源地址Hash法(Hash...
  • jeffleo
  • jeffleo
  • 2017年03月29日 15:05
  • 374
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:几种常见的负载均衡算法实现
举报原因:
原因补充:

(最多只允许输入30个字)