轮询
算法思想：在服务器的处理能力相同，请求处理量差异不大的情况下，可以按照负载服务器的顺序均匀的分配给每台服务器，这种均匀分配请的方式成为轮询。
代码实例：
public static Map<String, Integer> serverWeightMap = new HashMap<String,Integer>();
public static Integer pos = 0;
public NewTest(String[] args) throws Exception, Exception{
serverWeightMap.put("192.168.121.12", 1);
serverWeightMap.put("192.168.121.13", 1);
serverWeightMap.put("192.168.121.14", 4);
serverWeightMap.put("192.168.121.15", 1);
serverWeightMap.put("192.168.121.16", 1);
serverWeightMap.put("192.168.121.17", 3);
serverWeightMap.put("192.168.121.18", 1);
serverWeightMap.put("192.168.121.19", 2);
serverWeightMap.put("192.168.121.20", 1);
serverWeightMap.put("192.168.121.21", 1);
serverWeightMap.put("192.168.121.22", 1);
}
//轮询法
public static String testRoundRobin() throws Exception, IOException {
Map<String, Integer> serverMap = new HashMap<String,Integer>();
serverMap.putAll(serverWeightMap);
Set<String> keySet = serverMap.keySet();
ArrayList<String> list = new ArrayList<String>();
list.addAll(keySet);
String server = "";
synchronized (pos) {
if (pos>=keySet.size()) {
pos=0;
}
server = list.get(pos);
pos++;
}
return server;
}
nginx配置：
upstream tomcats {
server 192.168.0.100:8080;
server 192.168.0.101:8080;
}
随机
算法思想：客户端的请求到达后台，负载策略会随机性的从负载ip列表中获取一个服务器对请求进行处理。
代码实例：
//随机算法
public static String testRandom(){
String server = "";
Map<String, Integer> serverMap = new HashMap<String,Integer>();
serverMap.putAll(serverWeightMap);
Set<String> keySet = serverMap.keySet();
ArrayList<String> list = new ArrayList<String>();
list.addAll(keySet);
Random random = new Random();
int randomip = random.nextInt(keySet.size());
server = list.get(randomip);
return server;
}
加权轮询
算法思想：设置一个列表用来维护负载ip，按照ip的权重将该ip添加到列表中多次，权重是几就要添加几次，客户端的请求会按照顺序分配给ip列表中的某一个ip。
代码实例：
public static String testWeightRoundRobin(){
String server = "";
Map<String, Integer> serverMap = new HashMap<String,Integer>();
serverMap.putAll(serverWeightMap);
Set<String> keySet = serverMap.keySet();
Iterator<String> iterator = keySet.iterator();
ArrayList<String> list = new ArrayList<String>();
while(iterator.hasNext()){
String ip = iterator.next();
Integer weight = serverMap.get(ip);
for(int i=0;i<weight;i++){
list.add(ip);
}
}
synchronized (pos) {
if (pos>=list.size()) {
pos=0;
}
server = list.get(pos);
pos++;
}
return server;
}
nginx配置：
upstream back_opencache {
server 10.159.39.136:12082 weight=2 max_fails=3 fail_timeout=10s;
server 10.159.39.137:12082 weight=2 max_fails=3 fail_timeout=10s;
}
加权随机
算法思想：按照每个负载ip的权重来设置在ip列表中出现的概率，比重越大概率越大，同时在客户端请求到达负载时，首先要获取一个随机数，通过随机数来获取负载ip列表中的敷在服务器，权重越大获取到的概率也会越大。。
代码实例：
public static String testWeightRandom() {
String server = "";
Map<String, Integer> serverMap = new HashMap<String,Integer>();
serverMap.putAll(serverWeightMap);
Set<String> keySet = serverMap.keySet();
ArrayList<String> list = new ArrayList<String>();
Iterator<String> iterator = keySet.iterator();
while(iterator.hasNext()){
String ip = iterator.next();
Integer weight = serverMap.get(ip);
for(int i=0;i<weight;i++){
list.add(ip);
}
}
Random random = new Random();
int randomip = random.nextInt(list.size());
server = list.get(randomip);
return server;
}
哈希一致
算法思想：在客户端发送请求时，服务器会判断客户端的ip的hash值，将取到的hash值与负载服务器的总数取模，按照模值获取负载ip列表中的服务器。
代码实例：
public static String testConsumerHash(String ip){
String server = "";
Map<String, Integer> serverMap = new HashMap<String,Integer>();
serverMap.putAll(serverWeightMap);
Set<String> keySet = serverMap.keySet();
ArrayList<String> list = new ArrayList<String>();
int hashCode = ip.hashCode();
int serverPos = hashCode%list.size();
server = list.get(serverPos);
return server;
}
nginx配置：
upstream back_openfacade {
ip_hash;
server 10.159.39.136:12083;
server 10.159.39.137:12083;
}
最小连接数
即使后端机器的性能和负载一样，不同客户端请求复杂度不一样导致处理时间也不一样。最小连接数法根据后端服务器当前的连接数情况，动态地选取其中积压连接数最小的一台服务器来处理当前的请求，尽可能提高后端服务器的利用效率，合理地将请求分流到每一台服务器。
nginx配置：
upstream back_opencache {
least_conn;
server 10.159.39.136:12082 weight=2 max_fails=3 fail_timeout=10s;
server 10.159.39.137:12082 weight=2 max_fails=3 fail_timeout=10s;
}
