java">private static Map<String, Integer> serviceWeightMap = new HashMap<String, Integer>();
static {
    serviceWeightMap.put("192.168.1.100", 1);
    serviceWeightMap.put("192.168.1.101", 1);		 // 权重为4
    serviceWeightMap.put("192.168.1.102", 4);
    serviceWeightMap.put("192.168.1.103", 1);
    serviceWeightMap.put("192.168.1.104", 1);        // 权重为3
    serviceWeightMap.put("192.168.1.105", 3);
    serviceWeightMap.put("192.168.1.106", 1);        // 权重为2
    serviceWeightMap.put("192.168.1.107", 2);
    serviceWeightMap.put("192.168.1.108", 1);
    serviceWeightMap.put("192.168.1.109", 1);
    serviceWeightMap.put("192.168.1.110", 1);
}

一、轮询法（Round Robin）

对所有的服务器节点全部按顺序来，将请求按照顺序轮流地分配到各个服务器上，所以适合用于服务器硬件条件基本都相同的情况

java">private static Integer pos = 0;
 
public static String testRoundRobin() {   
    // 重新创建一个map，避免出现由于服务器上线和下线导致的并发问题
    Map<String, Integer> serverMap = new HashMap<String, Integer>();
    serverMap.putAll(serviceWeightMap);
     
    // 取得 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 = 0;
        }
        server = keyList.get(pos);
        pos++;
    }
    return server;
}

由于 serviceWeightMap 中的地址列表是动态的，随时可能由机器上线、下线或者宕机，因此，为了避免可能出现的并发问题，比如数组越界，通过在方法内新建局部变量 serverMap，先将域变量拷贝到线程本地，避免被其他线程修改。这样可能会引入新的问题，当被拷贝之后，serviceWeightMap 的修改将无法被 serverMap 感知，也就是说，在这一轮的选择服务器中，新增服务器或者下线服务器，负载均衡算法中将无法获知。新增比较好处理，而当服务器下线或者宕机时，服务消费者将有可能访问不到不存在的地址。 因此，在服务消费者服务端需要考虑该问题，并且进行相应的容错处理，比如重新发起一次调用

对于当前轮询的位置变量 pos，为了保证服务器选择的顺序性，需要在操作时对其加锁，使得同一时刻只能有一个线程可以修改 pos 的值，否则当 pos 变量被并发修改，则无法保证服务器选择的顺序性，甚至有可能导致 keyList 数组越界

轮询法的优点在于：试图做到请求转移的绝对均衡，缺点在于：为了做到请求转移的绝对均衡，必须付出相当大的代价，因为为了保证 pos 变量修改的互斥性，需要引入重量级的悲观锁 synchronized，这将会导致该段轮询代码的并发吞吐量发生明显的下降

二、加权轮询法（Weight Robin）

那么加权轮询算法无疑就是对各个服务器有了"高低贵贱之分"，没办法，服务器的吃力水平不同，只能让那些强悍的机器优先并多处理一些请求，比较弱的机器就让它稍稍压力小一点

java">public class WeightRoundRobin {
    private static Integer pos;

    public static String getServer() {
        // 重建一个Map，避免服务器的上下线导致的并发问题
        Map<String, Integer> serverMap = new HashMap<String, Integer>();
        serverMap.putAll(IpMap.serverWeightMap);

        // 取得 Ip 地址 List
        Set<String> keySet = serverMap.keySet();
        Iterator<String> iterator = keySet.iterator();

        List<String> serverList = new ArrayList<String>();
        while (iterator.hasNext()) {
            String server = iterator.next();
            int weight = serverMap.get(server);
            for (int i = 0; i < weight; i++)
                serverList.add(server);
        }

        String server = null;
        synchronized (pos){
            if (pos > keySet.size())
                pos = 0;
            server = serverList.get(pos);
            pos ++;
        }

        return server;
    }
}

与轮询法类似，只是在获取服务器地址之前增加了一段权重计算的代码，根据权重的大小，将地址重复地增加到服务器地址列表中，权重越大，该服务器每轮所获得的请求数量越多

三、随机法（Random）

随机算法也是一种使用场景比较多的负载均衡算法，这种算法基本思想也是很简单的，随机生成一个数字（或者随机挑一个IP地址）出来，然后挑到谁就是谁，当然，如果随机数是等概况生成的，那时间长了，基本上跟轮询算法没有什么区别，区别最主要的还是在顺序上，随机算法没有那么严格的顺序

java">public class Random {
    public static String getServer() {
        // 重建一个Map，避免服务器的上下线导致的并发问题
        Map<String, Integer> serverMap = new HashMap<String, Integer>();
        serverMap.putAll(IpMap.serverWeightMap);

        // 取得 Ip 地址 List
        Set<String> keySet = serverMap.keySet();
        ArrayList<String> keyList = new ArrayList<String>();
        keyList.addAll(keySet);

        java.util.Random random = new java.util.Random();
        int randomPos = random.nextInt(keyList.size());
        return keyList.get(randomPos);
    }
}

四、加权随机法（Weight Random）

加权随机算法是在随机算法的基础上加了加权的条件，随机法时间长了，基本上跟一般轮询算法就没啥区别了，刚才也说到了，如果服务器的配置都差不多，可以分配差不多的任务，但是如果服务器吃力能力差异比较大，那水平高的和水平低的服务器都给那么多任务，对于高配置的服务器来说就是有点浪费了，对于低配置的服务器来说就有点吃不消，所以在这种配置差异性比较大的情况下，加权的工作还是必要的

java">public class WeightRandom {
    public static String getServer() {
        // 重建一个 Map，避免服务器的上下线导致的并发问题
        Map<String, Integer> serverMap = new HashMap<String, Integer>();
        serverMap.putAll(IpMap.serverWeightMap);

        // 取得 Ip 地址 List
        Set<String> keySet = serverMap.keySet();
        Iterator<String> iterator = keySet.iterator();

        List<String> serverList = new ArrayList<String>();
        while (iterator.hasNext()) {
            String server = iterator.next();
            int weight = serverMap.get(server);
            for (int i = 0; i < weight; i++)
                serverList.add(server);
        }

        java.util.Random random = new java.util.Random();
        int randomPos = random.nextInt(serverList.size());
        return serverList.get(randomPos);
    }
}

五、最小连接法（Least Connections）

那个服务器的连接数少，就分配给哪个服务器新的请求，合情合理，这种算法的缺点就是，当一个比较弱的服务器和一个比较彪悍的服务器，本来就是前者连接的要少，后者要大，如果非要谁的少新请求分配给谁的话，那就是弱服务器的连接要等于强服务器的连接，无疑这样会让弱服务器吃不消，或者造成强服务器的浪费，所以这里还可以使用加权的方法解决这样的问题------加权最小连接法

六、源地址哈希法（Hash）

源地址哈希法可以把客户端的 IP 地址拿出来，然后计算出 IP 地址的 hash 值，根据 hash 值映射到服务器上

java">public class Hash {
    public static String getServer() {
        // 重建一个 Map，避免服务器的上下线导致的并发问题
        Map<String, Integer> serverMap = new HashMap<String, Integer>();
        serverMap.putAll(IpMap.serverWeightMap);

        // 取得 Ip 地址 List
        Set<String> keySet = serverMap.keySet();
        ArrayList<String> keyList = new ArrayList<String>();
        keyList.addAll(keySet);

        // 在 Web 应用中可通过 HttpServlet 的 getRemoteIp 方法获取
        String remoteIp = "127.0.0.1";
        int hashCode = remoteIp.hashCode();
        int serverListSize = keyList.size();
        int serverPos = hashCode % serverListSize;

        return keyList.get(serverPos);
    }
}