Detail the Java load balancing algorithm code

This paper mainly introduces several Java algorithms for load balancing, specifically as follows:

Polling:

package class2.zookeeper.loadbalance;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/**
 *  The equilibrium algorithm, the method 
 * @author guoy
 *
 */
public class TestRoundRobin {

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

   static{
    serverWeigthMap.put("192.168.1.12", 1);
    serverWeigthMap.put("192.168.1.13", 1);
    serverWeigthMap.put("192.168.1.14", 2);
    serverWeigthMap.put("192.168.1.15", 2);
    serverWeigthMap.put("192.168.1.16", 3);
    serverWeigthMap.put("192.168.1.17", 3);
    serverWeigthMap.put("192.168.1.18", 1);
    serverWeigthMap.put("192.168.1.19", 2);
  }
   Integer pos = 0;
   public String roundRobin()
    {
      // To establish a 1 � map, Avoid sending messages to and from the server 
      Map<String,Integer> serverMap = new HashMap<String,Integer>();
      serverMap.putAll(serverWeigthMap);
      //  �  take ip The list of 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 = 0;
        }
        server = keyList.get(pos);
        pos ++;
      }
      return server;
    }
    
    public static void main(String[] args) {
      TestRoundRobin robin = new TestRoundRobin();
      for (int i = 0; i < 20; i++) {
        String serverIp = robin.roundRobin();
        System.out.println(serverIp);
      }
    }
}

Weighted polling:

package class2.zookeeper.loadbalance;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.Set;

/**
 *  Add the load balancing algorithm 
 * @author guoy
 *
 */
public class TestWeightRandom {
  
  static Map<String,Integer> serverWeigthMap = new HashMap<String,Integer>();

   static{
    serverWeigthMap.put("192.168.1.12", 1);
    serverWeigthMap.put("192.168.1.13", 1);
    serverWeigthMap.put("192.168.1.14", 2);
    serverWeigthMap.put("192.168.1.15", 2);
    serverWeigthMap.put("192.168.1.16", 3);
    serverWeigthMap.put("192.168.1.17", 3);
    serverWeigthMap.put("192.168.1.18", 1);
    serverWeigthMap.put("192.168.1.19", 2);
  }

  public static String weightRandom()
  {
    // To establish a 1 � map, Avoid sending messages to and from the server 
    Map<String,Integer> serverMap = new HashMap<String,Integer>();
    serverMap.putAll(serverWeigthMap);
    //  �  take ip The list of 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);
      }
    }    
    Random random = new Random();
    int randomPos = random.nextInt(serverList.size());
    
    String server = serverList.get(randomPos);
    return server;
  }
  
  public static void main(String[] args) {
    String serverIp = weightRandom();
    System.out.println(serverIp);
  }
}

Random:

package class2.zookeeper.loadbalance;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Random;
import java.util.Set;

/**
 *  Load balancing algorithm 
 * @author guoy
 *
 */
public class TestRandom {
  
  static Map<String,Integer> serverWeigthMap = new HashMap<String,Integer>();

   static{
    serverWeigthMap.put("192.168.1.12", 1);
    serverWeigthMap.put("192.168.1.13", 1);
    serverWeigthMap.put("192.168.1.14", 2);
    serverWeigthMap.put("192.168.1.15", 2);
    serverWeigthMap.put("192.168.1.16", 3);
    serverWeigthMap.put("192.168.1.17", 3);
    serverWeigthMap.put("192.168.1.18", 1);
    serverWeigthMap.put("192.168.1.19", 2);
  }

  public static String random()
  {
    // To establish a 1 � map, Avoid sending messages to and from the server 
    Map<String,Integer> serverMap = new HashMap<String,Integer>();
    serverMap.putAll(serverWeigthMap);
    //  �  take ip The list of 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;
  }
  
  public static void main(String[] args) {
    String serverIp = random();
    System.out.println(serverIp);
  }
}

Weighted random:

package class2.zookeeper.loadbalance;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.Set;

/**
 *  Add the load balancing algorithm 
 * @author guoy
 *
 */
public class TestWeightRandom {
  
  static Map<String,Integer> serverWeigthMap = new HashMap<String,Integer>();

   static{
    serverWeigthMap.put("192.168.1.12", 1);
    serverWeigthMap.put("192.168.1.13", 1);
    serverWeigthMap.put("192.168.1.14", 2);
    serverWeigthMap.put("192.168.1.15", 2);
    serverWeigthMap.put("192.168.1.16", 3);
    serverWeigthMap.put("192.168.1.17", 3);
    serverWeigthMap.put("192.168.1.18", 1);
    serverWeigthMap.put("192.168.1.19", 2);
  }

  public static String weightRandom()
  {
    // To establish a 1 � map, Avoid sending messages to and from the server 
    Map<String,Integer> serverMap = new HashMap<String,Integer>();
    serverMap.putAll(serverWeigthMap);
    //  �  take ip The list of 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);
      }
    }    
    Random random = new Random();
    int randomPos = random.nextInt(serverList.size());
    
    String server = serverList.get(randomPos);
    return server;
  }
  
  public static void main(String[] args) {
    String serverIp = weightRandom();
    System.out.println(serverIp);
  }
}

ip hash:

package class2.zookeeper.loadbalance;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/**
 *  Load balancing  ip_hash algorithm 
 * @author guoy
 *
 */
public class TestIpHash {

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

   static{
    serverWeigthMap.put("192.168.1.12", 1);
    serverWeigthMap.put("192.168.1.13", 1);
    serverWeigthMap.put("192.168.1.14", 2);
    serverWeigthMap.put("192.168.1.15", 2);
    serverWeigthMap.put("192.168.1.16", 3);
    serverWeigthMap.put("192.168.1.17", 3);
    serverWeigthMap.put("192.168.1.18", 1);
    serverWeigthMap.put("192.168.1.19", 2);
  }

   /**
   *  Gets the address of the requesting server 
   * @param remoteIp  Load balancing server ip
   * @return
   */
  public static String ipHash(String remoteIp)
  {
    // To establish a 1 � map, Avoid sending messages to and from the server 
    Map<String,Integer> serverMap = new HashMap<String,Integer>();
    serverMap.putAll(serverWeigthMap);
    //  �  take ip The list of 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 void main(String[] args) {
    String serverIp = ipHash("192.168.1.12");
    System.out.println(serverIp);
  }

}