轮询

  1. package class2.zookeeper.loadbalance;
  2.  
  3. import java.util.ArrayList;
  4. import java.util.HashMap;
  5. import java.util.Map;
  6. import java.util.Set;
  7.  
  8. /**
  9.  * 負載均衡算法，輪詢法
  10.  * @author guoy
  11.  *
  12.  */
  13. public class TestRoundRobin {
  14.  
  15.     static Map<String,Integer> serverWeigthMap  = new HashMap<String,Integer>();
  16.  
  17.      static{
  18.         serverWeigthMap.put("192.168.1.12", 1);
  19.         serverWeigthMap.put("192.168.1.13", 1);
  20.         serverWeigthMap.put("192.168.1.14", 2);
  21.         serverWeigthMap.put("192.168.1.15", 2);
  22.         serverWeigthMap.put("192.168.1.16", 3);
  23.         serverWeigthMap.put("192.168.1.17", 3);
  24.         serverWeigthMap.put("192.168.1.18", 1);
  25.         serverWeigthMap.put("192.168.1.19", 2);
  26.     }
  27.      Integer  pos = 0;
  28.      public  String roundRobin()
  29.         {
  30.             //重新建立一個map,避免出現由於服務器上線和下線導致的並發問題
  31.             Map<String,Integer> serverMap  = new HashMap<String,Integer>();
  32.             serverMap.putAll(serverWeigthMap);
  33.             //獲取ip列表list
  34.             Set<String> keySet = serverMap.keySet();
  35.             ArrayList<String> keyList = new ArrayList<String>();
  36.             keyList.addAll(keySet);
  37.  
  38.             String server = null;
  39.  
  40.             synchronized (pos) {
  41.                 if(pos >=keySet.size()){
  42.                     pos = 0;
  43.                 }
  44.                 server = keyList.get(pos);
  45.                 pos ++;
  46.             }
  47.             return server;
  48.         }
  49.  
  50.         public static void main(String[] args) {
  51.             TestRoundRobin robin = new TestRoundRobin();
  52.             for (int i = 0; i < 20; i++) {
  53.                 String serverIp = robin.roundRobin();
  54.                 System.out.println(serverIp);
  55.             }
  56.         }
  57. }

加权轮询

  1. package class2.zookeeper.loadbalance;
  2.  
  3. import java.util.ArrayList;
  4. import java.util.HashMap;
  5. import java.util.Iterator;
  6. import java.util.List;
  7. import java.util.Map;
  8. import java.util.Random;
  9. import java.util.Set;
  10.  
  11. /**
  12.  * 加權隨機载均衡算法
  13.  * @author guoy
  14.  *
  15.  */
  16. public class TestWeightRandom {
  17.  
  18.     static Map<String,Integer> serverWeigthMap  = new HashMap<String,Integer>();
  19.  
  20.      static{
  21.         serverWeigthMap.put("192.168.1.12", 1);
  22.         serverWeigthMap.put("192.168.1.13", 1);
  23.         serverWeigthMap.put("192.168.1.14", 2);
  24.         serverWeigthMap.put("192.168.1.15", 2);
  25.         serverWeigthMap.put("192.168.1.16", 3);
  26.         serverWeigthMap.put("192.168.1.17", 3);
  27.         serverWeigthMap.put("192.168.1.18", 1);
  28.         serverWeigthMap.put("192.168.1.19", 2);
  29.     }
  30.  
  31.     public static String weightRandom()
  32.     {
  33.         //重新建立一個map,避免出現由於服務器上線和下線導致的並發問題
  34.         Map<String,Integer> serverMap  = new HashMap<String,Integer>();
  35.         serverMap.putAll(serverWeigthMap);
  36.         //獲取ip列表list
  37.         Set<String> keySet = serverMap.keySet();
  38.         Iterator<String> it = keySet.iterator();
  39.  
  40.         List<String> serverList = new ArrayList<String>();
  41.  
  42.         while (it.hasNext()) {
  43.             String server = it.next();
  44.             Integer weight = serverMap.get(server);
  45.             for (int i = 0; i < weight; i++) {
  46.                 serverList.add(server);
  47.             }
  48.         }
  49.         Random random = new Random();
  50.         int randomPos = random.nextInt(serverList.size());
  51.  
  52.         String server = serverList.get(randomPos);
  53.         return server;
  54.     }
  55.  
  56.     public static void main(String[] args) {
  57.         String serverIp = weightRandom();
  58.         System.out.println(serverIp);
  59.     }
  60. }

随机

  1. package class2.zookeeper.loadbalance;
  2.  
  3. import java.util.ArrayList;
  4. import java.util.HashMap;
  5. import java.util.Map;
  6. import java.util.Random;
  7. import java.util.Set;
  8.  
  9. /**
  10.  * 隨機负载均衡算法
  11.  * @author guoy
  12.  *
  13.  */
  14. public class TestRandom {
  15.  
  16.     static Map<String,Integer> serverWeigthMap  = new HashMap<String,Integer>();
  17.  
  18.      static{
  19.         serverWeigthMap.put("192.168.1.12", 1);
  20.         serverWeigthMap.put("192.168.1.13", 1);
  21.         serverWeigthMap.put("192.168.1.14", 2);
  22.         serverWeigthMap.put("192.168.1.15", 2);
  23.         serverWeigthMap.put("192.168.1.16", 3);
  24.         serverWeigthMap.put("192.168.1.17", 3);
  25.         serverWeigthMap.put("192.168.1.18", 1);
  26.         serverWeigthMap.put("192.168.1.19", 2);
  27.     }
  28.  
  29.     public static String random()
  30.     {
  31.         //重新建立一個map,避免出現由於服務器上線和下線導致的並發問題
  32.         Map<String,Integer> serverMap  = new HashMap<String,Integer>();
  33.         serverMap.putAll(serverWeigthMap);
  34.         //獲取ip列表list
  35.         Set<String> keySet = serverMap.keySet();
  36.         ArrayList<String> keyList = new ArrayList<String>();
  37.         keyList.addAll(keySet);
  38.  
  39.         Random random = new Random();
  40.         int randomPos = random.nextInt(keyList.size());
  41.  
  42.         String server = keyList.get(randomPos);
  43.         return server;
  44.     }
  45.  
  46.     public static void main(String[] args) {
  47.         String serverIp = random();
  48.         System.out.println(serverIp);
  49.     }
  50. }

加权随机

  1. package class2.zookeeper.loadbalance;
  2.  
  3. import java.util.ArrayList;
  4. import java.util.HashMap;
  5. import java.util.Iterator;
  6. import java.util.List;
  7. import java.util.Map;
  8. import java.util.Random;
  9. import java.util.Set;
  10.  
  11. /**
  12.  * 加權隨機载均衡算法
  13.  * @author guoy
  14.  *
  15.  */
  16. public class TestWeightRandom {
  17.  
  18.     static Map<String,Integer> serverWeigthMap  = new HashMap<String,Integer>();
  19.  
  20.      static{
  21.         serverWeigthMap.put("192.168.1.12", 1);
  22.         serverWeigthMap.put("192.168.1.13", 1);
  23.         serverWeigthMap.put("192.168.1.14", 2);
  24.         serverWeigthMap.put("192.168.1.15", 2);
  25.         serverWeigthMap.put("192.168.1.16", 3);
  26.         serverWeigthMap.put("192.168.1.17", 3);
  27.         serverWeigthMap.put("192.168.1.18", 1);
  28.         serverWeigthMap.put("192.168.1.19", 2);
  29.     }
  30.  
  31.     public static String weightRandom()
  32.     {
  33.         //重新建立一個map,避免出現由於服務器上線和下線導致的並發問題
  34.         Map<String,Integer> serverMap  = new HashMap<String,Integer>();
  35.         serverMap.putAll(serverWeigthMap);
  36.         //獲取ip列表list
  37.         Set<String> keySet = serverMap.keySet();
  38.         Iterator<String> it = keySet.iterator();
  39.  
  40.         List<String> serverList = new ArrayList<String>();
  41.  
  42.         while (it.hasNext()) {
  43.             String server = it.next();
  44.             Integer weight = serverMap.get(server);
  45.             for (int i = 0; i < weight; i++) {
  46.                 serverList.add(server);
  47.             }
  48.         }
  49.         Random random = new Random();
  50.         int randomPos = random.nextInt(serverList.size());
  51.  
  52.         String server = serverList.get(randomPos);
  53.         return server;
  54.     }
  55.  
  56.     public static void main(String[] args) {
  57.         String serverIp = weightRandom();
  58.         System.out.println(serverIp);
  59.     }
  60. }

ip hash

  1. package class2.zookeeper.loadbalance;
  2.  
  3. import java.util.ArrayList;
  4. import java.util.HashMap;
  5. import java.util.Map;
  6. import java.util.Set;
  7.  
  8. /**
  9.  * 负载均衡 ip_hash算法
  10.  * @author guoy
  11.  *
  12.  */
  13. public class TestIpHash {
  14.  
  15.     static Map<String,Integer> serverWeigthMap  = new HashMap<String,Integer>();
  16.  
  17.      static{
  18.         serverWeigthMap.put("192.168.1.12", 1);
  19.         serverWeigthMap.put("192.168.1.13", 1);
  20.         serverWeigthMap.put("192.168.1.14", 2);
  21.         serverWeigthMap.put("192.168.1.15", 2);
  22.         serverWeigthMap.put("192.168.1.16", 3);
  23.         serverWeigthMap.put("192.168.1.17", 3);
  24.         serverWeigthMap.put("192.168.1.18", 1);
  25.         serverWeigthMap.put("192.168.1.19", 2);
  26.     }
  27.  
  28.      /**
  29.       * 获取请求服务器地址
  30.       * @param remoteIp 负载均衡服务器ip
  31.       * @return
  32.       */
  33.     public static String ipHash(String remoteIp)
  34.     {
  35.         //重新建立一個map,避免出現由於服務器上線和下線導致的並發問題
  36.         Map<String,Integer> serverMap  = new HashMap<String,Integer>();
  37.         serverMap.putAll(serverWeigthMap);
  38.         //獲取ip列表list
  39.         Set<String> keySet = serverMap.keySet();
  40.         ArrayList<String> keyList = new ArrayList<String>();
  41.         keyList.addAll(keySet);
  42.  
  43.         int hashCode =remoteIp.hashCode();
  44.         int serverListSize = keyList.size();
  45.         int serverPos = hashCode % serverListSize;
  46.  
  47.         return keyList.get(serverPos);
  48.     }
  49.  
  50.     public static void main(String[] args) {
  51.         String serverIp = ipHash("192.168.1.12");
  52.         System.out.println(serverIp);
  53.     }
  54.  
  55. }

负载均衡的几种算法Java实现代码的更多相关文章

  1. nignx 负载均衡的几种算法介绍

    负载均衡,集群必须要掌握,下面介绍的负载均衡的几种算法.   1 .轮询,即所有的请求被一次分发的服务器上,每台服务器处理请求都相同,适合于计算机硬件相同.   2.加权轮询,高的服务器分发更多的请求 ...

  2. 浅析负载均衡的6种算法，Ngnix的5种算法。

    浅析负载均衡的6种算法,Ngnix的5种算法.浮生偷闲百家号03-21 10:06关注内容导读其实际效果越来越接近于平均分配调用量到后端的每一台服务器,也就是轮询的结果.源地址哈希的思想是根据获取客 ...

  3. 浅析负载均衡的6种算法，Ngnix的5种算法

    常见的几种负载均衡算法 1.轮询法 将请求按顺序轮流地分配到后端服务器上,它均衡地对待后端的每一台服务器,而不关心服务器实际的连接数和当前的系统负载. 2.随机法 通过系统的随机算法,根据后端服务器的 ...

  4. [转]nginx负载均衡的五种算法

    1.round robin(默认) 轮询方式,依次将请求分配到各个后台服务器中,默认的负载均衡方式. 适用于后台机器性能一致的情况. 挂掉的机器可以自动从服务列表中剔除. 2.weight 根据权重来 ...

  5. LVS负载均衡的三种模式和八种算法总结

    三种LVS负载均衡模式 调度器的实现技术中,IP负载均衡技术是效率最高的,IP虚拟服务器软件(IPVS)是在linux内核中实现的｡ LVS负载均衡模式---1.NAT模式 NAT用法本来是因为网络I ...

  6. Nginx负载均衡的4种方式 ：轮询-Round Robin 、Ip地址-ip_hash、最少连接-least_conn、加权-weight=n

    这里对负载均衡概念和nginx负载均衡实现方式做一个总结: 先说一下负载均衡的概念: Load Balance负载均衡是用于解决一台机器(一个进程)无法解决所有请求而产生的一种算法. 我们知道单台服务 ...

  7. Nginx实现负载均衡的几种方式

    负载均衡的几种常用方式 1.轮询(默认) 每个请求按时间顺序逐一分配到不同的后端服务器,如果后端服务器down掉,能自动剔除. upstream backserver { server 192.168 ...

  8. 分布式系统的负载均衡以及ngnix负载均衡的五种策略

    一般而言,有以下几种常见的负载均衡策略: 一.轮询. 特点:给每个请求标记一个序号,然后将请求依次派发到服务器节点中,适用于集群中各个节点提供服务能力等同且无状态的场景. 缺点:该策略将节点视为等同, ...

  9. 【Nginx】实现负载均衡的几种方式

    要理解负载均衡,必须先搞清楚正向代理和反向代理. 注: 正向代理,代理的是用户. 反向代理,代理的是服务器 什么是负载均衡 当一台服务器的单位时间内的访问量越大时,服务器压力就越大,大到超过自身承受能 ...

随机推荐

  1. 偏移：translate ，旋转：rotate，缩放 scale，不知道什么东东：lineCap 实例

    <!DOCTYPE HTML> <head> <meta charset = "utf-8"> <title>canvas</ ...

  2. sql server2014不允许保存更改。阻止保存要求重新创建表的更改

    错误描述: SQL Server2014在原有的数据表中修改表结构后,保存数据表,提示错误如下: 不允许保存更改.您所做的更改要求删除并重新创建以下您对无法重新创建的表进行了更改或启用了"阻 ...

  3. C# Lambda表达式

    C# Lambda表达式 Lambda表达式 "Lambda表达式"是一个匿名函数,是一种高效的类似于函数式编程的表达式,Lambda简化了开发中需要编写的代码量.它可以包含表达式 ...

  4. Swift实现封装PopMenu菜单，可在屏幕任意位置弹出

    效果图: 说明: 代码现已支持 Swift3 语法 使用介绍: 1.初始化位置 //frame 为整个popview相对整个屏幕的位置 箭头距离右边位置,默认15 //popMenu = SwiftP ...

  5. awk-实践

    实际中遇到的问题 字符串截取函数 substr #!/usr/bin/awk #author:zhaoyingnan #filename:substr.awk #substr 函数 #|awk -f ...

  6. OpenStack 企业私有云的若干需求（6）：大规模扩展性支持

    本系列会介绍OpenStack 企业私有云的几个需求: 自动扩展(Auto-scaling)支持 多租户和租户隔离 (multi-tenancy and tenancy isolation) 混合云( ...

  7. Serial Port Programming on Linux(转载)

    This is a tutorial on how to program the Serial Ports on your Linux box.Serial Ports are nice little ...

  8. 【每日一linux命令6】命令中的命令

    许多命令在执行后,会进入该命令的操作模式,如 fdisk.pine.top 等,进入后我们必须要使用该 命令中的命令,才能正确执行:而一般要退出该命令,可以输入 exit.q.quit 或是按[Ctr ...

  9. Unity Shader入门

    Unity Shader入门 http://www.cnblogs.com/lixiang-share/p/5025662.html http://www.manew.com/blog-30559-1 ...

  10. IntelliJ IDEA设置JVM运行参数

    2015十一月 28 原 IntelliJ IDEA设置JVM运行参数 分类:JavaSE (11566) (1) 打开 IDEA 安装目录,看到有一个 bin 目录,其中有两个 vmoptions ...