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

原创 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;
    }
}
版权声明:本文为博主原创文章,未经博主允许不得转载。

常见的几种负载均衡

1.HTTP重定向 2.DNS负载均衡:保持一个会话在一台服务器上是一个问题 3.ip负载均衡 :http://www.360doc.com/content/12/1117/19/820209_2...
  • le119126
  • le119126
  • 2015年04月02日 17:36
  • 707

nginx做负载均衡的几种方式

最近看了一些nginx做负载均衡的文章,在这里留下笔记,方便以后再次学习查看。 不喜勿喷...
  • psy1100
  • psy1100
  • 2017年05月02日 15:02
  • 1780

GC算法和种类【重要】

【声明】  欢迎转载,但请保留文章原始出处→_→  生命壹号:http://www.cnblogs.com/smyhvae/ 文章来源:http://www.cnblogs.com/smyhvae/p...
  • z3881006
  • z3881006
  • 2017年02月13日 16:21
  • 648

几种常见排序算法实现

#include #include #include #pragma comment(linker,"/subsystem:console") using namespace std; const i...
  • u013189665
  • u013189665
  • 2014年06月20日 22:38
  • 360

web应用负载均衡策略

1.  名词解释 1.  正向代理与反向代理 简单说 我们内网访问facebook用的代理就叫正向代理 从美国访问我们内网需要的代理就叫反向代理   多台服务器处于一个内网,而我们要访问这些服务器,中...
  • flyhawk_xjtu
  • flyhawk_xjtu
  • 2016年03月02日 15:18
  • 2141

负载均衡的基本(常用)算法

平衡算法设计的好坏直接决定了集群在负载均衡上的表现,设计不好的算法,会导致集群的负载失衡。一般的平衡算法主要任务是决定如何选择下一个集群节点,然后将新的服务请求转发给它。有些简单平衡方法可以独立使用,...
  • liuguiyangnwpu
  • liuguiyangnwpu
  • 2014年05月06日 12:34
  • 12738

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

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

几种常见的排序算法实现

1. 插入排序//插入排序 #include using namespace std;//每次遍历将第i个数插入到前i-1个数中(前i-1个数已排好序) void insertSort(int a[...
  • u011954296
  • u011954296
  • 2016年07月12日 20:55
  • 208

常用的负载均衡技术

DNS 轮询 DNS 轮询是指将同一个域名解析到不同的 IP,随机使用其中某台主机的技术。但其具有明显的缺点:一旦某个服务器出现故障,即使及时修改了 DNS 设置,还是要等待足够的时间(刷新...
  • rznice
  • rznice
  • 2014年02月09日 22:33
  • 1032

LVS:三种负载均衡方式比较+另三种负载均衡方式

什么是LVS?  首先简单介绍一下LVS (Linux Virtual Server)到底是什么东西,其实它是一种集群(Cluster)技术,采用IP负载均衡技术和基于内容请求分发技术。调度器具有很好...
  • u013256816
  • u013256816
  • 2016年02月20日 18:06
  • 6815
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:几种常见的负载均衡算法实现
举报原因:
原因补充:

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