一、一致性哈希算法 —ConsistentHashLoadBalance
服务器集群接收到一次请求调用时，可以根据请求的信息，比如客户端的IP地址，或请求路径与请求参数等信息进行哈希，可以得到一个哈希值，特点是对于相同的IP地址，或请求路径与请求参数哈希出来的值一样的，只要能再添加一个算法，就能够把哈希值映射成一个服务端IP地址，就可以使相同的请求（相同的IP地址，或请求路径与请求参数）落到同一服务器上。
因为客户段发起的请况是无穷无尽的（客户端地址不同，请求参数不同等等），所以对于其哈希值也是无穷大的，所以我们不鞥把所有的哈希值都进行映射到服务端IP上，所以这里需要用户哈希环。如下图：
上面这情况是比较均匀情况，如果出现ip4服务器不存在，那就是下面这样了：
会发现，ip3和ip1之间的范围是比较发的，会有更多的请求落在ip1上，这是不“公平的”，解决这个问题需要加入虚拟节点，比如：
其实ip2-1,ip3-1就是虚拟节点，并不能处理节点，而是等同于对于的ip2和ip3服务器。
实际上，这只是处理这种不均衡性的一种思路，实际上，就算哈希环本身是均衡的，你也可以增加更多的虚拟节点来使这个环更加平滑，比如：
这个彩环也是“公平的”，并且只有ip1,2,3,4是实际上的服务器ip，其他的都是虚拟ip。
那么我们怎么来实现呢？
对于我们的服务器ip地址，我们肯定知道总共有多少个，需要多少个虚拟节点也由我们自己控制，虚拟节点越多则流量越均衡，另外哈希算法也是很关键的，哈希算法越散列流量也将越均衡。
实现：
public class ServerIps {
public static final List<String> LIST = Arrays.asList(
"192.168.0.1",
"192.168.0.2",
"192.168.0.3",
"192.168.0.4",
"192.168.0.5",
"192.168.0.6",
"192.168.0.7",
"192.168.0.8",
"192.168.0.9",
"192.168.0.10"
);
/**
* 哈希环算法
*/
public class ConsistentHash {
private static SortedMap<Integer, String> virtualNodes = new TreeMap<>();
private static final int VIRTUAL_NODES = 160;
static {
// 对每个真实节点添加虚拟节点，虚拟节点会根据哈希算法进行散列
for (String ip : ServerIps.LIST) {
for (int i = 0; i < VIRTUAL_NODES; i++) {
int hash = getHash(ip+"VN"+i);
virtualNodes.put(hash, ip);
}
}
}
private static String getServer(String client) {
int hash = getHash(client);
// 得到大于该Hash值的排好序的Map
SortedMap<Integer, String> subMap = virtualNodes.tailMap(hash);
// 大于该hash值的第一个元素的位置
Integer nodeIndex = subMap.firstKey();
// 如果不存在大于该hash值的元素，则返回根节点
if (nodeIndex == null) {
nodeIndex = virtualNodes.firstKey();
return virtualNodes.get(nodeIndex);
}
//返回对应的虚拟节点名称
return subMap.get(nodeIndex);
}
//hash算法
private static int getHash(String str) {
final int p = 16777619;
int hash = (int) 2166136261L;
for (int i = 0; i < str.length(); i++)
hash = (hash ^ str.charAt(i)) * p;
hash += hash << 13;
hash ^= hash >> 7;
hash += hash << 3;
hash ^= hash >> 17;
hash += hash << 5;
// 如果算出来的值为负数则取其绝对值
if (hash < 0)
hash = Math.abs(hash);
return hash;
}
public static void main(String[] args) {
// 连续调用10次，随机10个client
for (int i = 0; i < 10; i++) {
System.out.println(getServer("client" + i));
}
}
}
二、最小活跃数算法 — LeastActiveLoadbalance
实现：
因为活跃数是需要服务器请求处理相关逻辑配合的，一次调用开始时活跃数+1，结束时活跃数-1，所以这里就不对部分逻辑进行模拟来，只是使用一个map来进行模拟。
public class ServerIps {
public static final Map<String, Integer> WEIGHT_LIST = new HashMap<String, Integer>();
static {
// 权重之和为50
WEIGHT_LIST.put("192.168.0.1", 1);
WEIGHT_LIST.put("192.168.0.2", 8);
WEIGHT_LIST.put("192.168.0.3", 3);
WEIGHT_LIST.put("192.168.0.4", 6);
WEIGHT_LIST.put("192.168.0.5", 5);
WEIGHT_LIST.put("192.168.0.6", 5);
WEIGHT_LIST.put("192.168.0.7", 4);
WEIGHT_LIST.put("192.168.0.8", 7);
WEIGHT_LIST.put("192.168.0.9", 2);
WEIGHT_LIST.put("192.168.0.10", 9);
}
// 服务器当前的活跃数
public static final Map<String, Integer> ACTIVITY_LIST = new LinkedHashMap<>();
static {
ACTIVITY_LIST.put("192.168.0.1", 2);
ACTIVITY_LIST.put("192.168.0.2", 0);
ACTIVITY_LIST.put("192.168.0.3", 1);
ACTIVITY_LIST.put("192.168.0.4", 3);
ACTIVITY_LIST.put("192.168.0.5", 0);
ACTIVITY_LIST.put("192.168.0.6", 1);
ACTIVITY_LIST.put("192.168.0.7", 4);
ACTIVITY_LIST.put("192.168.0.8", 2);
ACTIVITY_LIST.put("192.168.0.9", 7);
ACTIVITY_LIST.put("192.168.0.10", 3);
}
}
/**
* 最小活跃数算法
*/
public class LeastActive {
private static String getServer() {
// 找出当前活跃数最小的服务器
Optional<Integer> minValue =
ServerIps.ACTIVITY_LIST.values().stream().min(Comparator.naturalOrder());
if (minValue.isPresent()) {
List<String> minActivityIps = new ArrayList<>();
ServerIps.ACTIVITY_LIST.forEach((ip, activity) -> {
if (activity.equals(minValue.get())) {
minActivityIps.add(ip);
}
});
// 最小活跃数的ip有多个，则根据权重来选，权重大的优先
if (minActivityIps.size() > 1) {
// 过滤出对应的ip和权重
Map<String, Integer> weightList = new LinkedHashMap<>();
ServerIps.WEIGHT_LIST.forEach((ip, weight) -> {
if (minActivityIps.contains(ip)) {
weightList.put(ip, ServerIps.WEIGHT_LIST.get(ip));
}
});
int totalWeight = 0;
boolean sameWeight = true; // 如果所以权重都相等，那么随机一个ip就好了
Object[] weights = weightList.values().toArray();
for (int i = 0; i < weights.length; i++) {
Integer weight = (Integer) weights[i];
totalWeight += weight;
if (sameWeight && i > 0 && !weight.equals(weights[i - 1])) {
sameWeight = false;
}
}
java.util.Random random = new java.util.Random();
int randomPos = random.nextInt(totalWeight);
if (!sameWeight) {
for (String ip : weightList.keySet()) {
Integer value = weightList.get(ip);
if (randomPos < value) {
return ip;
}
randomPos = randomPos - value;
}
}
return (String) weightList.keySet().toArray()[new java.util.Random().nextInt(weightList.size())];
} else {
return minActivityIps.get(0);
}
} else {
return (String) ServerIps.WEIGHT_LIST.keySet().toArray()
[new java.util.Random().nextInt(ServerIps.WEIGHT_LIST.size())];
}
}
public static void main(String[] args) {
// 连续调用10次，随机10个client
for (int i = 0; i < 10; i++) {
System.out.println(getServer());
}
}
}
这里因为不会对活跃数进行操作，所以结果都是固定的（担任在随机权重的时候会随机，具体看源码实现，以及运行结果即可理解。）
每台服务器的活跃数具体实现要由框架去记录 一个请求的生命周期。
三、负载均衡总结
以上均为鲁班学院学习资料，欢迎大家报班学习，真心推荐！
