Java负载均衡算法实现之轮询和加权轮询

/**

  * 普通轮询算法

  */ public class RoundRobin {

     private static Integer index = 0 ;

     private static List<String> nodes = new ArrayList<>();

     // 准备模拟数据

     static {

         nodes.add( "192.168.1.101" );

         nodes.add( "192.168.1.103" );

         nodes.add( "192.168.1.102" );

         System.out.println( "普通轮询算法的所有节点：" +nodes); //打印所有节点

     }

     // 关键代码

     public String selectNode(){

         String ip = null ;

         synchronized (index){

             // 下标复位

             if (index>=nodes.size()) index = 0 ;

             ip = nodes.get(index);

             index++;

         }

         return ip;

     }

     // 并发测试：两个线程循环获取节点

     public static void main(String[] args) {

         new Thread(() -> {

             RoundRobin roundRobin1 = new RoundRobin();

             for ( int i= 1 ;i<= 5 ;i++){

                 String serverIp = roundRobin1.selectNode();

                 System.out.println(Thread.currentThread().getName()+ "==第" +i+ "次获取节点：" +serverIp);

             }

         }).start();

         RoundRobin roundRobin2 = new RoundRobin();

         for ( int i= 1 ;i<=nodes.size();i++){

             String serverIp = roundRobin2.selectNode();

             System.out.println(Thread.currentThread().getName()+ "==第" +i+ "次获取节点：" +serverIp);

         }

     }

}

/**

  *  简单版的加权轮询

  */ public class WeightedRoundRobinSimple {

     private static Integer index = 0 ;

     private static Map<String,Integer> mapNodes = new HashMap<>();

     // 准备模拟数据

     static {

         mapNodes.put( "192.168.1.101" , 1 );

         mapNodes.put( "192.168.1.102" , 3 );

         mapNodes.put( "192.168.1.103" , 2 );

         /* -- 以下代码只为了方便查看所有节点，删除不影响 -- S */

         List<String> nodes = new ArrayList<>();

         Iterator<Map.Entry<String, Integer>> iterator = mapNodes.entrySet().iterator();

         while (iterator.hasNext()){

             Map.Entry<String, Integer> entry = iterator.next();

             String key = entry.getKey();

             for ( int i= 0 ;i<entry.getValue();i++){

                 nodes.add(key);

             }

         }

         System.out.println( "简单版的加权轮询：" +nodes); //打印所有节点

         /* -- 以上代码只为了方便查看所有节点，删除不影响-- E */

     }

     // 关键代码：类似于二维数组 降维成 一维数组，然后使用普通轮询

     public String selectNode(){

         List<String> nodes = new ArrayList<>();

         Iterator<Map.Entry<String, Integer>> iterator = mapNodes.entrySet().iterator();

         while (iterator.hasNext()){

             Map.Entry<String, Integer> entry = iterator.next();

             String key = entry.getKey();

             for ( int i= 0 ;i<entry.getValue();i++){

                 nodes.add(key);

             }

         }

         String ip = null ;

         synchronized (index){

             // 下标复位

             if (index>=nodes.size()) index = 0 ;

             ip = nodes.get(index);

             index++;

         }

         return ip;

     }

     // 并发测试：两个线程循环获取节点

     public static void main(String[] args) {

         new Thread(() -> {

             WeightedRoundRobinSimple roundRobin1 = new WeightedRoundRobinSimple();

             for ( int i= 1 ;i<= 6 ;i++){

                 String serverIp = roundRobin1.selectNode();

                 System.out.println(Thread.currentThread().getName()+ "==第" +i+ "次获取节点：" +serverIp);

             }

         }).start();

         WeightedRoundRobinSimple roundRobin2 = new WeightedRoundRobinSimple();

         for ( int i= 1 ;i<= 6 ;i++){

             String serverIp = roundRobin2.selectNode();

             System.out.println(Thread.currentThread().getName()+ "==第" +i+ "次获取节点：" +serverIp);

         }

     }

}

/**

  * String ip：负载IP

  * final Integer weight：权重，保存配置的权重

  * Integer effectiveWeight：有效权重，轮询的过程权重可能变化

  * Integer currentWeight：当前权重，比对该值大小获取节点

  *   第一次加权轮询时：currentWeight = weight = effectiveWeight

  *   后面每次加权轮询时：currentWeight 的值都会不断变化，其他权重不变

  */ public class Node implements Comparable<Node>{

     private String ip;

     private final Integer weight;

     private Integer effectiveWeight;

     private Integer currentWeight;

     public Node(String ip,Integer weight){

         this .ip = ip;

         this .weight = weight;

         this .effectiveWeight = weight;

         this .currentWeight = weight;

     }

     public Node(String ip, Integer weight, Integer effectiveWeight, Integer currentWeight) {

         this .ip = ip;

         this .weight = weight;

         this .effectiveWeight = effectiveWeight;

         this .currentWeight = currentWeight;

     }

     public String getIp() {

         return ip;

     }

     public void setIp(String ip) {

         this .ip = ip;

     }

     public Integer getWeight() {

         return weight;

     }

     public Integer getEffectiveWeight() {

         return effectiveWeight;

     }

     public void setEffectiveWeight(Integer effectiveWeight) {

         this .effectiveWeight = effectiveWeight;

     }

     public Integer getCurrentWeight() {

         return currentWeight;

     }

     public void setCurrentWeight(Integer currentWeight) {

         this .currentWeight = currentWeight;

     }

     @Override

     public int compareTo(Node node) {

         return currentWeight > node.currentWeight ? 1 : (currentWeight.equals(node.currentWeight) ? 0 : - 1 );

     }

     @Override

     public String toString() {

         return "{ip='" + ip + "', weight=" + weight + ", effectiveWeight=" + effectiveWeight + ", currentWeight=" + currentWeight + "}" ;

     }

}

/**

  * 加权轮询算法

  */ public class WeightedRoundRobin {

     private static List<Node> nodes = new ArrayList<>();

     // 权重之和

     private static Integer totalWeight = 0 ;

     // 准备模拟数据

     static {

         nodes.add( new Node( "192.168.1.101" , 1 ));

         nodes.add( new Node( "192.168.1.102" , 3 ));

         nodes.add( new Node( "192.168.1.103" , 2 ));

         nodes.forEach(node -> totalWeight += node.getEffectiveWeight());

     }

     /**

      * 按照当前权重（currentWeight）最大值获取IP

      * @return Node

      */

     public Node selectNode(){

         if (nodes == null || nodes.size()<= 0 ) return null ;

         if (nodes.size() == 1 )  return nodes.get( 0 );

         Node nodeOfMaxWeight = null ; // 保存轮询选中的节点信息

         synchronized (nodes){

             // 打印信息对象：避免并发时打印出来的信息太乱，不利于观看结果

             StringBuffer sb = new StringBuffer();

             sb.append(Thread.currentThread().getName()+ "==加权轮询--[当前权重]值的变化：" +printCurrentWeight(nodes));

             // 选出当前权重最大的节点

             Node tempNodeOfMaxWeight = null ;

             for (Node node : nodes) {

                 if (tempNodeOfMaxWeight == null )

                     tempNodeOfMaxWeight = node;

                 else

                     tempNodeOfMaxWeight = tempNodeOfMaxWeight.compareTo(node) > 0 ? tempNodeOfMaxWeight : node;

             }

             // 必须new个新的节点实例来保存信息，否则引用指向同一个堆实例，后面的set操作将会修改节点信息

             nodeOfMaxWeight = new Node(tempNodeOfMaxWeight.getIp(),tempNodeOfMaxWeight.getWeight(),tempNodeOfMaxWeight.getEffectiveWeight(),tempNodeOfMaxWeight.getCurrentWeight());

             // 调整当前权重比：按权重（effectiveWeight）的比例进行调整，确保请求分发合理。

             tempNodeOfMaxWeight.setCurrentWeight(tempNodeOfMaxWeight.getCurrentWeight() - totalWeight);

             sb.append( " -> " +printCurrentWeight(nodes));

             nodes.forEach(node -> node.setCurrentWeight(node.getCurrentWeight()+node.getEffectiveWeight()));

             sb.append( " -> " +printCurrentWeight(nodes));

             System.out.println(sb); //打印权重变化过程

         }

         return nodeOfMaxWeight;

     }

     // 格式化打印信息

     private String printCurrentWeight(List<Node> nodes){

         StringBuffer stringBuffer = new StringBuffer( "[" );

         nodes.forEach(node -> stringBuffer.append(node.getCurrentWeight()+ "," ) );

         return stringBuffer.substring( 0 , stringBuffer.length() - 1 ) + "]" ;

     }

     // 并发测试：两个线程循环获取节点

     public static void main(String[] args){

         Thread thread = new Thread(() -> {

             WeightedRoundRobin weightedRoundRobin1 = new WeightedRoundRobin();

             for ( int i= 1 ;i<=totalWeight;i++){

                 Node node = weightedRoundRobin1.selectNode();

                 System.out.println(Thread.currentThread().getName()+ "==第" +i+ "次轮询选中[当前权重最大]的节点：" + node + "\n" );

             }

         });

         thread.start();

         //

         WeightedRoundRobin weightedRoundRobin2 = new WeightedRoundRobin();

         for ( int i= 1 ;i<=totalWeight;i++){

             Node node = weightedRoundRobin2.selectNode();

             System.out.println(Thread.currentThread().getName()+ "==第" +i+ "次轮询选中[当前权重最大]的节点：" + node + "\n" );

         }

     }

}